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

CODING_STANDARDS

@@ -0,0 +1,148 @@
+PHP Coding Standards
+====================
+
+
+This file lists several standards that any programmer, adding or changing
+code in PHP, should follow.  Since this file was added at a very late
+stage of the development of PHP v3.0, the code base does not (yet) fully
+follow it, but it's going in that general direction.
+This is an initial version - it'll most probably grow as time passes.
+
+
+Code Implementation
+-------------------
+
+[1] Functions that are given pointers to resources should not free them
+
+For instance, function int mail(char *to, char *from) should NOT free
+to and/or from.
+Exceptions:
+
+  - The function's designated behavior is freeing that resource.  E.g. efree()
+  - The function is given a boolean argument, that controls whether or not
+    the function may free its arguments (if true - the function must free its
+    arguments, if false - it must not)
+  - Low-level parser routines, that are tightly integrated with the token
+    cache and the bison code for minimum memory copying overhead.
+    
+[2] Functions that are tightly integrated with other functions within the
+    same module, and rely on each other non-trivial behavior, should be
+    documented as such and declared 'static'.  They should be avoided if
+    possible.
+
+[3] Use definitions and macros whenever possible, so that constants have
+    meaningful names and can be easily manipulated.  The only exceptions
+    to this rule are 0 and 1, when used as false and true (respectively).
+    Any other use of a numeric constant to specify different behavior
+    or actions should be done through a #define.
+
+[4] When writing functions that deal with strings, be sure to remember
+    that PHP holds the length property of each string, and that it
+    shouldn't be calculated with strlen().  Write your functions in a such
+    a way so that they'll take advantage of the length property, both
+    for efficiency and in order for them to be binary-safe.
+    Functions that change strings and obtain their new lengths while
+    doing so, should return that new length, so it doesn't have to be
+    recalculated with strlen() (e.g. php_addslashes())
+
+[5] Use php_error() to report any errors/warnings during code execution.
+    Use descriptive error messages, and try to avoid using identical
+    error strings for different stages of an error.  For example,
+    if in order to obtain a URL you have to parse the URL, connect,
+    and retreive the text, assuming something can go wrong at each
+    of these stages, don't report an error "Unable to get URL"
+    on all of them, but instead, write something like "Unable
+    to parse URL", "Unable to connect to URL server" and "Unable
+    to fetch URL text", respectively.
+
+[6] NEVER USE strncat().  If you're absolutely sure you know what you're doing,
+    check its man page again, and only then, consider using it, and even then,
+    try avoiding it.
+
+
+Naming Conventions
+------------------
+
+[1] Function names for user functions should be enclosed with in
+    the PHP_FUNCTION() macro.  
+
+[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'.
+    
+[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++) ...).
+
+[4] Variable names should be in lowercase;  Use underscores to seperate
+    between words.
+
+
+Syntax and indentation
+----------------------
+
+[1] Never use C++ style comments (i.e. // comment).  Always use C-style
+    comments instead.  PHP is written in C, and is aimed at compiling
+    under any ANSI-C compliant compiler.  Even though many compilers
+    accept C++-style comments in C code, you have to ensure that your
+    code would compile with other compilers as well.
+    The only exception to this rule is code that is Win32-specific,
+    because the Win32 port is MS-Visual C++ specific, and this compiler
+    is known to accept C++-style comments in C code.
+
+[2] Use K&R-style.  Of course, we can't and don't want to
+    force anybody to use a style she's not used to, but
+    at the very least, when you write code that goes into the core
+    of PHP or one of its standard modules, please maintain the K&R
+    style.  This applies to just about everything, starting with
+    indentation and comment styles and up to function decleration
+    syntax.
+    
+[3] Be generous with whitespace and braces.  Always prefer
+    if (foo) {
+		bar;
+	}
+	to
+	if(foo)bar;
+	
+    Keep one empty line between the variable decleration section and
+    the statements in a block, as well as between logical statement
+    groups in a block.  Maintain at least one empty line between
+    two functions, preferably two.
+
+Documentation and Folding Hooks
+-------------------------------
+
+In order to make sure that the online documentation stays in line with
+the code, each user-level function should have its user-level function
+prototype before it along with a brief one-line description of what the
+function does.  It would look like this:
+
+/* {{{ proto int abs(int number)
+   Return the absolute value of the number */
+PHP_FUNCTION(abs)
+{
+   ...
+}
+/* }}} */
+
+The {{{ symbols are the default folding symbols for the folding mode in
+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
+function prototypes allows us to put folds elsewhere in the code without
+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]]])
+
+And yes, please keep everything on a single line, even if that line is massive.
+
+

CREDITS

@@ -0,0 +1,2 @@
+For the list of people who've put work into PHP 4.0, please see
+http://www.php.net/credits.php

EXTENSIONS

@@ -0,0 +1,352 @@
+                     List of PHP maintainers
+                     =======================
+
+Maintenance legend
+------------------
+    Supported:       Someone is actually paid to look after this.
+    Maintained:      Someone actually looks after it.
+    Odd Fixes:       It has a maintainer but they don't have time to do
+                     much other than throw the odd patch in. See below.
+    Orphan:          No current maintainer [but maybe you could take the
+                     role as you write your new code].
+    Obsolete:        Old code. Something tagged obsolete generally means
+                     it has been replaced by a better system and you
+                     should be using that.
+    Unknown:         Not known at this time.
+
+Status legend
+-------------
+    Working:         Working under both Windows and Unix.
+    Windows:         Working only under Windows.
+    Unix:            Working only under Unix.
+    Experimental:    Under development or initial release.
+    Not Working:     Not working.
+    Unknown:         Status unknown.
+
+
+== Server APIs ==
+
+-------------------------------------------------------------------------------
+EXTENSION:           aolserver
+MAINTENANCE:         Unknown
+STATUS:              Unknown
+-------------------------------------------------------------------------------
+EXTENSION:           apache
+PRIMARY MAINTAINER:  Rasmus Lerdorf <rasmus@php.net>
+MAINTENANCE:         Maintained
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           cgi
+MAINTENANCE:         Unknown
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           fhttpd
+MAINTENANCE:         Unknown
+STATUS:              Unknown
+-------------------------------------------------------------------------------
+EXTENSION:           isapi
+MAINTENANCE:         Unknown
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           nsapi
+MAINTENANCE:         Unknown
+STATUS:              Unknown
+-------------------------------------------------------------------------------
+EXTENSION:           phttpd
+MAINTENANCE:         Unknown
+STATUS:              Unknown
+-------------------------------------------------------------------------------
+EXTENSION:           pi3web
+MAINTENANCE:         Unknown
+STATUS:              Unknown
+-------------------------------------------------------------------------------
+EXTENSION:           roxen
+MAINTENANCE:         Unknown
+STATUS:              Unknown
+-------------------------------------------------------------------------------
+EXTENSION:           servlet
+PRIMARY MAINTAINER:  Sam Ruby <rubys@us.ibm.com>
+MAINTENANCE:         Maintained
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           thttpd
+MAINTENANCE:         Unknown
+STATUS:              Unknown
+-------------------------------------------------------------------------------
+
+
+== Database extensions ==
+
+-------------------------------------------------------------------------------
+EXTENSION:           dba
+PRIMARY MAINTAINER:  Sascha Schumann <sascha@schumann.cx>
+MAINTENANCE:         Maintained
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           dbase
+PRIMARY MAINTAINER:  Jim Winstead <jimw@php.net>
+MAINTENANCE:         Odd Fixes
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           filepro
+MAINTENANCE:         Unknown
+STATUS:              Unknown
+-------------------------------------------------------------------------------
+EXTENSION:           hyperwave
+PRIMARY MAINTAINER:  Uwe Steinmann <steinm@php.net>
+MAINTENANCE:         Maintained
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           informix
+PRIMARY MAINTAINER:  Danny Heijl <Danny.Heijl@cevi.be>
+MAINTENANCE:         Maintained
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           ingres_ii
+PRIMARY MAINTAINER:  David Hénot <henot@php.net>
+MAINTENANCE:         Maintained
+STATUS:              Experimental
+SINCE:               4.0.2
+-------------------------------------------------------------------------------
+EXTENSION:           interbase
+PRIMARY MAINTAINER:  Jouni Ahto <jah@mork.net>
+MAINTENANCE:         Odd Fixes
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           msql
+MAINTENANCE:         Unknown
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           mssql
+PRIMARY MAINTAINER:  Frank M. Kromann <fmk@swwwing.com>
+MAINTENANCE:         Maintained
+STATUS:              Working
+COMMENT:             Tested on phpts and isapi versions
+-------------------------------------------------------------------------------
+EXTENSION:           mysql
+MAINTENANCE:         Unknown
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           pgsql
+PRIMARY MAINTAINER:  Jouni Ahto <jah@mork.net>
+MAINTENANCE:         Odd fixes
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           sybase
+MAINTENANCE:         Unknown
+STATUS:              Not Working
+-------------------------------------------------------------------------------
+EXTENSION:           sybase_ct
+MAINTENANCE:         Unknown
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           oci8
+PRIMARY MAINTAINER:  Thies C. Arntzen <thies@digicol.de>
+MAINTENANCE:         Maintained
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           odbc
+PRIMARY MAINTAINER:  Andreas Karajannis <Karajannis@gmd.de>
+MAINTENANCE:         Maintained
+STATUS:              Working
+COMMENT:             Working except for persistent connections
+-------------------------------------------------------------------------------
+EXTENSION:           oracle
+PRIMARY MAINTAINER:  Thies C. Arntzen <thies@digicol.de>
+MAINTENANCE:         Maintained
+STATUS:              Working
+COMMENT:             Using the new OCI8 driver is encouraged where possible.
+-------------------------------------------------------------------------------
+
+
+== Other extensions ==
+
+-------------------------------------------------------------------------------
+EXTENSION:           aspell
+MAINTENANCE:         Unknown
+STATUS:              Working
+COMMENT:             For aspell .27 and greater, check out the pspell extension
+-------------------------------------------------------------------------------
+EXTENSION:           bcmath
+MAINTENANCE:         Unknown
+STATUS:              Unknown
+-------------------------------------------------------------------------------
+EXTENSION:           calendar
+MAINTENANCE:         Unknown
+STATUS:              Unknown
+-------------------------------------------------------------------------------
+EXTENSION:           com
+MAINTENANCE:         Unknown
+STATUS:              Unknown
+-------------------------------------------------------------------------------
+EXTENSION:           cpdf
+PRIMARY MAINTAINER:  Uwe Steinmann <steinm@php.net>
+MAINTENANCE:         Maintained
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           CURL
+PRIMARY MAINTAINER:  Sterling Hughes <sterling@php.net>
+MAINTENANCE:         Maintained
+STATUS:              Experimental
+SINCE:               4.0.2
+-------------------------------------------------------------------------------
+EXTENSION:           cybercash
+PRIMARY MAINTAINER:  Evan Klinger <evan715@sirius.com>
+MAINTENANCE:         Maintained
+STATUS:              Unknown
+-------------------------------------------------------------------------------
+EXTENSION:           domxml
+PRIMARY MAINTAINER:  Uwe Steinmann <steinm@php.net>
+MAINTENANCE:         Maintained
+STATUS:              Experimental
+-------------------------------------------------------------------------------
+EXTENSION:           dotnet
+PRIMARY MAINTAINER:  Sam Ruby <rubys@us.ibm.com>
+MAINTENANCE:         Maintained
+STATUS:              Experimental
+-------------------------------------------------------------------------------
+EXTENSION:           exif
+MAINTENANCE:         Unknown
+STATUS:              Unknown
+SINCE:               4.0.1
+-------------------------------------------------------------------------------
+EXTENSION:           fdf
+PRIMARY MAINTAINER:  Uwe Steinmann <steinm@php.net>
+MAINTENANCE:         Maintained
+STATUS:              Unknown
+-------------------------------------------------------------------------------
+EXTENSION:           ftp
+MAINTENANCE:         Unknown
+STATUS:              Unknown
+-------------------------------------------------------------------------------
+EXTENSION:           gd
+PRIMARY MAINTAINER:  Rasmus Lerdorf <rasmus@php.net>
+MAINTENANCE:         Maintained
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           gettext
+MAINTENANCE:         Unknown
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           icap
+MAINTENANCE:         Unknown
+STATUS:              Obsolete
+-------------------------------------------------------------------------------
+EXTENSION:           imap
+PRIMARY MAINTAINER:  Chuck Hagenbuch <chuck@horde.org>
+MAINTENANCE:         Odd Fixes
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           java
+PRIMARY MAINTAINER:  Sam Ruby <rubys@us.ibm.com>
+MAINTENANCE:         Maintained
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           ldap
+PRIMARY MAINTAINER:  Rasmus Lerdorf <rasmus@php.net>
+MAINTENANCE:         Odd Fixes
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           mcal
+PRIMARY MAINTAINER:  Chuck Hagenbuch <chuck@horde.org>
+MAINTENANCE:         Odd Fixes
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           mcrypt
+PRIMARY MAINTAINER:  Sascha Schumann <sascha@schumann.cx>
+MAINTENANCE:         Maintained
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           mhash
+PRIMARY MAINTAINER:  Sascha Schumann <sascha@schumann.cx>
+MAINTENANCE:         Maintained
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           pcre
+PRIMARY MAINTAINER:  Andrei Zmievski <andrei@ispi.net>
+MAINTENANCE:         Maintained
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           pdf
+PRIMARY MAINTAINER:  Uwe Steinmann <steinm@php.net>
+MAINTENANCE:         Maintained
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           pfpro
+PRIMARY MAINTAINER:  David Croft <david@infotrek.co.uk>
+MAINTENANCE:         Maintained
+STATUS:              Working
+SINCE:               4.0.2
+-------------------------------------------------------------------------------
+EXTENSION:           posix
+PRIMARY MAINTAINER:  Kristian Köhntopp <kris@koehntopp.de>
+MAINTENANCE:         Maintained
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           pspell
+PRIMARY MAINTAINER:  Vlad Krupin <phpdevel@echospace.com>
+MAINTENANCE:         Unknown
+STATUS:              Unknown
+SINCE:               4.0.2
+-------------------------------------------------------------------------------
+EXTENSION:           readline
+MAINTENANCE:         Unknown
+STATUS:              Unknown
+-------------------------------------------------------------------------------
+EXTENSION:           recode
+PRIMARY MAINTAINER:  Kristian Köhntopp <kris@koehntopp.de>
+MAINTENANCE:         Maintained
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           session
+PRIMARY MAINTAINER:  Sascha Schumann <sascha@schumann.cx>
+MAINTENANCE:         Maintained
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           snmp
+PRIMARY MAINTAINER:  Rasmus Lerdorf <rasmus@php.net>
+MAINTENANCE:         Odd Fixes
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           sockets
+PRIMARY MAINTAINER:  Chris Vandomelen <chrisv@b0rked.dhs.org>
+MAINTENANCE:         Unknown
+STATUS:              Unknown
+SINCE:               4.0.2
+-------------------------------------------------------------------------------
+EXTENSION:           swf
+PRIMARY MAINTAINER:  Sterling Hughes <sterling@php.net>
+MAINTENANCE:         Maintained
+STATUS:              Unix (won't change)
+-------------------------------------------------------------------------------
+EXTENSION:           sysvsem
+MAINTENANCE:         Unknown
+STATUS:              Unknown
+-------------------------------------------------------------------------------
+EXTENSION:           sysvshm
+MAINTENANCE:         Unknown
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           wddx
+PRIMARY MAINTAINER:  Andrei Zmievski <andrei@ispi.net>
+MAINTENANCE:         Maintained
+STATUS:              Working
+-------------------------------------------------------------------------------
+EXTENSION:           xml
+PRIMARY MAINTAINER:  Thies C. Arntzen <thies@digicol.de>
+MAINTENANCE:         Maintained
+STATUS:              Unknown
+-------------------------------------------------------------------------------
+EXTENSION:           yaz
+PRIMARY MAINTAINER:  Adam Dickmeiss <adam@indexdata.dk>
+MAINTENANCE:         Maintained
+STATUS:              Unknown
+SINCE:               4.0.1
+-------------------------------------------------------------------------------
+EXTENSION:           zlib
+PRIMARY MAINTAINER:  Stefan Roehrich <sr@linux.de>
+MAINTENANCE:         Maintained
+STATUS:              Working
+-------------------------------------------------------------------------------
+
+# 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

@@ -0,0 +1,405 @@
+Installation Instructions for PHP 4.0
+-------------------------------------
+
+For the impatient here is a quick set of steps that will build PHP as
+first a dynamic Apache module (DSO) for Apache 1.3.x with MySQL support 
+and then a static module.  A more verbose explanation follows.  
+
+For installing PHP on other web servers, refer to one of the following
+files:
+
+    sapi/aolserver/README
+    sapi/pi3web/README
+    sapi/servlet/README
+    sapi/thttpd/README
+    README.Zeus
+
+Note!  Only install either the static module or the dynamic one.  Do not
+install both.  
+
+Note 2!  If you are recompiling PHP to add new extensions or upgrading
+something like GD, remove the config.cache file before you re-run 
+configure.
+
+Note 3!  If you are on Linux and have installed shared libraries, make
+sure the location of these shared libraries are listed in your 
+/etc/ld.so.conf file.  For example, if you have:
+
+  /usr/local/lib/mysql/libmysqlclient.so
+
+Make sure /etc/ld.so.conf contains:
+
+  /usr/local/lib/mysql
+
+Then run ldconfig.
+
+If you want both PHP 3 and 4 modules in the same Apache server, check the
+bottom of this file for instructions.
+
+INSTALLATION WITH THE ZEUS WEB SERVER:
+--Please see the 'README.Zeus' file included in this distribution
+
+
+QUICK INSTALL (DSO)
+
+For this to work your Apache httpd must have mod_so enabled.
+Check using httpd -l.  You should see something like:
+
+Compiled-in modules:
+  http_core.c
+  mod_so.c
+
+Chances are you will see a lot more modules than these two. That's ok, 
+as long as mod_so.c shows up you can proceed with the following steps:
+
+$ gunzip -c php-4.0.x.tar.gz | tar xf -
+$ cd php-4.0.x
+$ ./configure --with-mysql --with-apxs
+$ make
+$ make install
+
+If you get an error telling you that the apxs script could not be found,
+look for it on your system and if you find it, provide the full path to it
+as: --with-apxs=/path/to/apxs
+
+Next you must copy php.ini-dist to the appropriate place (normally
+/usr/local/lib/php.ini) and edit it as necessary to set PHP options.
+
+The only thing left to do is to edit your httpd.conf file and make sure the
+PHP 4 mime type is there and uncommented.  You need a line that looks like
+this:
+
+   AddType application/x-httpd-php .php
+
+Then restart your server (apachectl restart) and you should be able to
+serve up PHP files now.  Make a test file called test.php and put some 
+PHP tags in it.  Like <?phpinfo()?>, for example.
+
+
+QUICK INSTALL (Static)
+
+$ gunzip -c apache_1.3.x.tar.gz | tar xf -
+$ cd apache_1.3.x
+$ ./configure
+$ cd ..
+
+$ gunzip -c php-4.0.x.tar.gz | tar xf -
+$ cd php-4.0.x
+$ ./configure --with-mysql --with-apache=../apache_1.3.x --enable-track-vars
+$ make
+$ make install
+
+$ cd ../apache_1.3.x
+$ ./configure --prefix=/www --activate-module=src/modules/php4/libphp4.a
+ (The above line is correct!  Yes, we know libphp4.a does not exist at this
+  stage.  It isn't supposed to.  It will be created.)
+$ make
+ (you should now have an httpd binary which you can copy to your Apache bin dir if
+  is is your first install then you need to "make install" as well)
+$ cd ../php-4.0.x
+$ cp php.ini-dist /usr/local/lib/php.ini
+You can edit /usr/local/lib/php.ini file to set PHP options.
+Edit your httpd.conf or srm.conf file and add:
+  AddType application/x-httpd-php .php
+
+
+VERBOSE INSTALL
+
+Chances are you are reading this because the quick install steps above
+did not work for you.  If this is the case, congratulations, you are
+among the elite few that actually reads documentation.  It really is
+not a difficult install and once you have done it once you will fly 
+through it.
+
+Installing PHP can be done in four simple steps:
+
+1. Unpack your distribution file.  
+
+   You will have downloaded a file named something like php-4.0.x.tar.gz.
+   Unzip this file with a command like: gunzip php-4.0.x.tar.gz
+
+   Next you have to untar it with: tar -xvf php-4.0.x.tar
+
+   This will create a php-4.0.x directory.  cd into this new directory.
+
+2a. Configure PHP (Dynamic Module) - Skip to 2b if you wish to build
+    a static module
+
+   You now have to choose the options you would like.  There are quite
+   a few of them.  To see a list, type: ./configure --help
+
+   The only options that you are likely to want to use are the ones in
+   the last section entitled, "--enable and --with options recognized:"
+
+   A popular choice is to build the Apache module version.  In order to
+   build PHP as a dynamic module for Apache-1.3.x you have to first have
+   Apache installed.  Assuming Apache is already installed, make sure
+   the shared object module is enabled.  To check this, type: httpd -l
+   You should see something like:
+
+     Compiled-in modules:
+       http_core.c
+       mod_so.c
+
+   You will most likely have a lot more modules than what is shown here.
+   As long as mod_so.c shows up in the list, PHP should be happy.
+
+   Now, type: ./configure --with-mysql --with-apxs
+
+   If you get an error telling you that the apxs script could not be found,
+   look for it on your system and if you find it, provide the full path to it
+   as: --with-apxs=/path/to/apxs
+
+   You might also want other flags on this configure line.  --with-mysql
+   is just an example.  
+
+   There are a few things that can go wrong during this configure step.
+   The most common is that you have asked for an option and that the
+   configure script can not find the files required to enable this 
+   option in PHP.  Chances are you can provide the full path to the
+   base directory under which the related files were installed.  For
+   example, if you have installed the GD library in /opt/gd which means
+   that /opt/gd/include has your GD header files and /opt/gd/lib contains
+   your GD library files, you would use --with-gd=/opt/gd
+
+   Skip to step 3 for compilation and installation instructions.
+
+2b. Configure PHP (Static Module) - Skip if you performed 2a
+
+   You now have to choose the options you would like.  There are quite
+   a few of them.  To see a list, type: ./configure --help
+
+   The only options that you are likely to want to use are the ones in
+   the last section entitled, "--enable and --with options recognized:"
+
+   A popular choice is to build the Apache module version.  You need
+   to know where the source code directory for your Apache server is
+   located.  Then use an option like: --with-apache=/usr/local/src/apache
+   if that is your Apache source code directory.  If you only specify
+   --with-apache, then it will default to look for your Apache source 
+   in /usr/local/etc/httpd.
+
+   NOTE: The directory you specify should be the top-level of the
+   unpacked Apache (or Stronghold) distribution. The configure program
+   will automatically look for httpd.h in different directories under that
+   location depending on which version of Apache, including Stronghold,
+   you are running.
+
+   For MySQL support, since newer versions of MySQL installs its various
+   components under /usr/local, this is the default.  If you have
+   changed the location you can specify it with: --with-mysql=/opt/local
+   for example.  Otherwise just use: --with-mysql
+
+   *NOTE*  If you are using Apache 1.3b6 or later, you should run the 
+   Apache Configure script at least once before compiling PHP.  It 
+   doesn't matter how you have Apache configured at this point.
+
+   Skip to step 3b at this point.
+
+3. Compile and install the files.  Simply type: make install
+
+3a.   Dynamic Module Installation
+
+   Nothing else is needed here.  Proceed to step 4a.
+
+3b.   Static Module Installation
+
+   For the Apache module version this will copy the appropriate files
+   to the src/modules/php4 directory in your Apache distribution if
+   you are using Apache 1.3.x.  If you are still running Apache 1.2.x
+   these files will be copied directly to the main src directory.
+
+   For Apache 1.3b6 and later, you can use the new APACI configuration
+   mechanism.  To automatically build Apache with PHP support, use:
+
+       cd apache_1.3.x
+       ./configure --prefix=/<path>/apache \
+                   --activate-module=src/modules/php4/libphp4.a
+       make
+       make install
+
+   If you do not wish to use this new configuration tool, the old
+   install procedure (src/Configure) will work fine.
+
+   If you are using the old Apache ./Configure script, you will have to 
+   edit the Apache src/Configuration file manually.  If you do not have 
+   this file, copy Configuration.tmpl to Configuration.
+
+   For Apache 1.3.x add:
+
+      AddModule modules/php4/libphp4.a
+
+   For Apache 1.3.x don't do anything else.  Just add this line and then
+   run "./Configure" followed by "make".
+
+   For Apache 1.2.x add:
+
+      Module php4_module mod_php4.o
+
+   For Apache 1.2.x you will also have to look in the libphp4.module file,
+   which was copied to the src directory. The EXTRA_LIBS line in the Apache
+   Configuration file needs to be set to use the same libs as specified on
+   the LIBS line in libphp4.module. You also need to make sure to add
+   "-L." to the beginning of the EXTRA_LIBS line.
+
+   So, as an example, your EXTRA_LIBS line might look like:
+
+	EXTRA_LIBS=-L. -lphp4 -lgdbm -ldb -L/usr/local/mysql/lib -lmysqlclient
+
+   NOTE: You should not enclose the EXTRA_LIBS line in double-quotes, as it
+   is in the libphp4.module file.
+
+   Also, look at the RULE_WANTHSREGEX setting in the libphp4.module file 
+   and set the WANTHSREGEX directive accordingly in your Configuration file.
+   This last step applies to versions of Apache prior to 1.3b3.
+
+   This is a bit of a hassle, but should serve as incentive to move to
+   Apache 1.3.x where this step has been eliminated.
+
+   Once you are satisfied with your Configuration settings, type: ./Configure
+   If you get errors, chances are that you forgot a library or made a typo
+   somewhere.  Re-edit Configuration and try again.  If it goes well,
+   type: make
+
+   Assuming it compiles without errors, proceed to step 4b.
+
+4a. Setting up the server. (Dynamic Module)
+
+   The make install command in step 3 should have done most of your
+   work for you.  It actually edits your httpd.conf file and tries to
+   enable the dynamic PHP module.  To verify this, look for a line that
+   looks like this:
+
+      LoadModule php4_module libexec/libphp4.so
+
+   The actual path before the libphp4.so part might differ slightly.  This
+   is likely fine.  If you are paranoid you can examine the output from the
+   make install step to see where the libphp4.so file was actually put and
+   place the full path to this file on this LoadModule line.
+
+   If somewhere in your httpd.conf file you have a ClearModuleList line
+   then you also need this line:
+
+      AddModule mod_php4.c
+
+   And finally you need to tell Apache which file extension should trigger
+   PHP.  You do this by creating a special mime type and associating it
+   with an extension.  We suggest using:
+
+      AddType application/x-httpd-php .php
+  
+   You are however free to use any extension you wish, including .html.
+
+   Note!  If a line has a # at the beginning, then it is commented out
+   and you need to remove the # for that line to take effect.
+
+   Finally you need to copy php.ini-dist to the appropriate place
+   (normally /usr/local/lib/php.ini) and edit if necessary.
+
+   Once you have made these changes you should be ready to restart your
+   server and try it out.  Type: apachectl restart
+   
+4b. Setting up the server. (Static Module)
+   
+   You should now have a new httpd binary.  Shut down your existing server,
+   if you have one, and copy this new binary overtop of it.  Perhaps make
+   a backup of your previous one first.  Then edit your conf/httpd.conf file
+   and add the line:
+
+      AddType application/x-httpd-php .php
+
+   There is also an interesting feature which can be quite instructive and
+   helpful while debugging.  That is the option of having colour syntax
+   highlighting.  To enable this, add the following line:
+
+      AddType application/x-httpd-php-source .phps
+
+   Any file ending in .phps will now be displayed with full colour syntax
+   highlighting instead of being executed.
+
+   Note that on some older server setups, the AddType lines are in the
+   conf/srm.conf file instead of conf/httpd.conf.
+
+   Note!  If a line has a # at the beginning, then it is commented out
+   and you need to remove the # for that line to take effect.
+
+   When you are finished making changes to your httpd.conf file, you need
+   to copy php.ini-dist to the appropriate place (normally
+   /usr/local/lib/php.ini) and edit if necessary. You can then
+   start up your server.
+
+5. Testing it all worked
+
+   Create a test file named test.php in your web tree somewhere and
+   put some test PHP tags in it.  <?phpinfo()?> is a good first test.
+   This tag tells PHP to do a braindump and tells you all sorts of things
+   about itself.  
+
+
+WHY DISABLING -fPIC WORKS ON LINUX
+
+    From: Martin v. Loewis <martin@loewis.home.cs.tu-berlin.de>
+    To: glibc-linux@ricardo.ecn.wfu.edu
+    Subject: Re: Shared library -shared vs. -fpic
+
+    [In reply to Kaz Kylheku <kaz@ashi.footprints.net>]
+
+    > PIC stands for Position-Independent Code. 
+
+    Correct.
+
+    > Code isn't position-independent (or ``relocatable'') cannot be
+    > loaded at an arbitrary address;
+
+    Wrong.
+
+    > it requires some references to be patched at load time.
+
+    Correct.
+
+    > Shared libraries need to be relocatable because it's not known
+    > beforehand what address they will be loaded at
+
+    Correct, depending on the meaning of "relocatable". PIC code typically
+    does not contain relocations; that's why its position-independent.
+
+    > Just because you don't specify -fPIC doesn't mean that the compiler
+    > won't emit position-independent code; the option prevents it from
+    > emitting position-dependent code in situations where it otherwise
+    > would.
+
+    Correct. However, a non-trivial shared library typically won't be
+    position-independent unless explicitly compiled with
+    -fPIC. Linux/glibc indeed does not require a shared library to be
+    position-independent; instead, it will perform the relocations in the
+    binary, even if they refer to code pages. As a result, those relocated
+    pages won't be shared across processes, anymore.
+
+    Regards,
+    Martin
+
+USING PHP 3 AND PHP 4 AS CONCURRENT APACHE MODULES
+
+   Recent operating systems provide the ability to perform versioning and
+   scoping. This features make it possible to let PHP 3 and PHP 4 run as
+   concurrent modules in one Apache server. 
+   
+   This feature is known to work on the following platforms:
+
+   - Linux with recent binutils (binutils 2.9.1.0.25 tested)
+   - Solaris 2.5 or better
+   - FreeBSD (3.2, 4.0 tested)
+   
+   To enable it, configure PHP 3 and PHP 4 to use APXS (--with-apxs) and the
+   necessary link extensions (--enable-versioning). Otherwise, all standard
+   installations instructions apply. For example:
+
+   		$ ./configure \
+				--with-apxs=/apache/bin/apxs \
+				--enable-versioning \
+				--with-mysql \
+				--enable-track-vars
+
+   If this also works on your platform or if you know a way to do it, please
+   report it to our bug database at http://bugs.php.net
+

LICENSE

@@ -0,0 +1,75 @@
+-------------------------------------------------------------------- 
+                  The PHP License, version 2.02
+Copyright (c) 1999, 2000 The PHP Group. All rights reserved.
+-------------------------------------------------------------------- 
+
+Redistribution and use in source and binary forms, with or without
+modification, is permitted provided that the following conditions
+are met:
+
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer. 
+ 
+  2. Redistributions in binary form must reproduce the above 
+     copyright notice, this list of conditions and the following 
+     disclaimer in the documentation and/or other materials provided
+     with the distribution.
+ 
+  3. The name "PHP" must not be used to endorse or promote products 
+     derived from this software without prior permission from the 
+     PHP Group.  This does not apply to add-on libraries or tools
+     that work in conjunction with PHP.  In such a case the PHP
+     name may be used to indicate that the product supports PHP.
+ 
+  4. The PHP Group may publish revised and/or new versions of the
+     license from time to time. Each version will be given a
+     distinguishing version number.
+     Once covered code has been published under a particular version
+     of the license, you may always continue to use it under the
+     terms of that version. You may also choose to use such covered
+     code under the terms of any subsequent version of the license
+     published by the PHP Group. No one other than the PHP Group has
+     the right to modify the terms applicable to covered code created
+     under this License.
+
+  5. Redistributions of any form whatsoever must retain the following
+     acknowledgment:
+     "This product includes PHP, freely available from
+     http://www.php.net/".
+
+  6. The software incorporates the Zend Engine, a product of Zend
+     Technologies, Ltd. ("Zend"). The Zend Engine is licensed to the
+     PHP Association (pursuant to a grant from Zend that can be
+     found at http://www.php.net/license/ZendGrant/) for
+     distribution to you under this license agreement, only as a
+     part of PHP.  In the event that you separate the Zend Engine
+     (or any portion thereof) from the rest of the software, or
+     modify the Zend Engine, or any portion thereof, your use of the
+     separated or modified Zend Engine software shall not be governed
+     by this license, and instead shall be governed by the license
+     set forth at http://www.zend.com/license/ZendLicense/. 
+
+
+
+THIS SOFTWARE IS PROVIDED BY THE PHP DEVELOPMENT TEAM ``AS IS'' AND 
+ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 
+PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE PHP
+DEVELOPMENT TEAM OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+OF THE POSSIBILITY OF SUCH DAMAGE.
+
+-------------------------------------------------------------------- 
+
+This software consists of voluntary contributions made by many
+individuals on behalf of the PHP Group.
+
+The PHP Group can be contacted via Email at group@php.net.
+
+For more information on the PHP Group and the PHP project, 
+please see <http://www.php.net>.

Makefile.in

@@ -0,0 +1,56 @@
+
+ZEND_DIR = $(srcdir)/Zend
+SUBDIRS = Zend main ext sapi $(TSRM_DIR) $(REGEX_DIR) . $(PEAR_DIR)
+
+LTLIBRARY_NAME = libphp4.la
+LTLIBRARY_SOURCES = stub.c
+
+LTLIBRARY_DEPENDENCIES = \
+		Zend/libZend.la \
+		sapi/$(PHP_SAPI)/libsapi.la \
+		main/libmain.la \
+		$(REGEX_LIB) \
+		$(EXT_LTLIBS) \
+		$(TSRM_LIB)
+
+LTLIBRARY_LDFLAGS = -rpath $(phptempdir) $(EXTRA_LDFLAGS) $(LDFLAGS) $(PHP_RPATHS)
+LTLIBRARY_LIBADD = $(LTLIBRARY_DEPENDENCIES) $(EXTRA_LIBS)
+
+PROGRAM_NAME         = php
+PROGRAM_SOURCES      = stub.c
+PROGRAM_LDADD        = libphp4.la
+PROGRAM_LDFLAGS      = -export-dynamic	
+PROGRAM_DEPENDENCIES = $(PROGRAM_LDADD)
+
+targets = $(LTLIBRARY_NAME) $(PHP_PROGRAM)
+
+install_targets = install-sapi install-modules
+
+include $(top_srcdir)/build/rules.mk
+include $(top_srcdir)/build/library.mk
+include $(top_srcdir)/build/program.mk
+
+install-sapi:
+	@$(LIBTOOL) --silent --mode=install cp libphp4.la $(phptempdir)/libphp4.la >/dev/null 2>&1
+	-@$(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 \
+				$(LN_S) $(phptempdir)/libphp4.$(SHLIB_SUFFIX_NAME).$$i $(phptempdir)/libphp4.$(SHLIB_SUFFIX_NAME); \
+				break; \
+			fi; \
+		done; \
+	fi
+	$(INSTALL_IT)
+
+install-modules:
+	@test -d modules && \
+	$(mkinstalldirs) $(moduledir) && \
+	echo "installing shared modules into $(moduledir)" && \
+	rm -f modules/*.la && \
+	cp modules/* $(moduledir) >/dev/null 2>&1 || true
+
+install-su: install-modules
+	(cd pear && $(MAKE) install)
+
+.NOEXPORT:

README.BCMATH

@@ -0,0 +1,17 @@
+How to install PHP with the BCMath arbitrary precision math library?
+--------------------------------------------------------------------
+
+Due to license restrictions, the BC math library can no longer be distributed
+along with PHP.  The BC math library is distributed under the restrictive
+GNU Public License, and PHP is no longer distributed under that license, but
+under a less restrictive license, the PHP License.
+
+If you want to enable BC math support (recommended), all you have to do is
+simply download http://www.php.net/extra/number4.tar.gz, and untar it on the
+top level php4 directory.
+
+A typical way of doing this would be (assuming that you have lynx):
+cd ~/php4
+lynx -dump -source http://www.php.net/extra/number4.tar.gz | gzip -d | tar xvf -
+
+The PHP Group

README.CVS-RULES

@@ -0,0 +1,104 @@
+This is the first file you should be reading after you get your CVS account.
+We'll assume you're basically familiar with CVS, but feel free to post
+your questions on the mailing list.
+
+PHP is developed through the efforts of a large number of people.
+Collaboration is a Good Thing(tm), and CVS lets us do this. Thus, following
+some basic rules with regards to CVS usage will:
+
+   a. Make everybody happier, especially those responsible for maintaining
+      the CVS itself.
+   b. Keep the changes consistently well documented and easily trackable.
+   c. Prevent some of those 'Oops' moments.
+   d. Increase the general level of good will on planet Earth.
+
+
+Having said that, here are the organizational rules:
+
+   1. Respect other people working on the project.
+
+   2. Discuss any significant changes on the list before committing. 
+
+   3. Look at EXTENSIONS file to see who is the primary maintainer of
+      the code you want to contribute to.
+
+   4. If you "strongly disagree" about something another person did, don't
+      start fighting publicly - take it up in private email.
+
+   5. If you don't know how to do something, ask first!
+
+   6. Test your changes before committing them. We mean it. Really.
+	
+
+The next few rules are more of a technical nature.
+
+   1. DO NOT TOUCH ChangeLog! It is automagically updated from the commit
+      messages every day. Woe be to those who attempt to mess with it.
+
+   2. All news updates intended for public viewing, such as new features,
+      bug fixes, improvements, etc., should go into the NEWS file. Also see
+      the note below about automatically updating NEWS in your commit message.
+
+   3. Do not commit multiple file and dump all messages in one commit. If you
+      modified several unrelated files, commit each group separately and
+      provide a nice commit message for each one. See example below.
+
+   4. Do write your commit message in such a way that it makes sense even
+      without the corresponding diff. One should be able to look at it, and
+      immediately know what was modified. Definitely include the function name
+      in the message as shown below.
+
+   5. In your commit messages, keep each line shorter than 80 characters. And
+      try to align your lines vertically, if they wrap. It looks bad otherwise.
+
+   6. If you modified a function that is callable from PHP, prepend PHP to
+      the function name as shown below.
+
+
+The format of the commit messages is pretty simple.
+
+If a line begins with #, it is taken to be a comment and will not appear
+in the ChangeLog.  If the line begins with @, it will be redirected to the
+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.
+
+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
+a memory leak in php_trim(). Don't commit both of these at once. Commit them
+separately and try to make sure your commit messages look something like the
+following.
+
+For datetime.c:
+
+(PHP date) Added new 'K' format modifier for printing out number of
+           days until New Year's Eve.
+@- Added new 'K' format modifier that will output the number of days
+@  until New Year's Eve. (Bob)
+
+For string.c:
+(php_trim) Fixed a memory leak resulting from improper use of zval_dtor().
+# Man, that thing was leaking all over the place!
+@- Memory leak in trim() function has finally been fixed. (Bob)
+
+The lines above marked with @ will go into NEWS file automagically, and the
+# lines will be omitted from the ChangeLog. Alternatively, you might want
+to modify NEWS file directly and not use the @ lines.
+
+If you don't see your messages in ChangeLog and NEWS right away, don't worry!
+These files are updated once a day, so your stuff will not show up until
+somewhat later. Don't go adding stuff to NEWS by hand if you already put @
+lines in the commit message.
+
+You can use LXR (http://lxr.php.net/) and Bonsai (http://bonsai.php.net/)
+to look at PHP CVS repository in various ways.
+
+To receive daily updates to ChangeLog and NEWS, send an empty message to
+php-cvs-daily-subscribe@lists.php.net.
+
+Happy hacking,
+
+PHP Team

README.EXT_SKEL

@@ -0,0 +1,181 @@
+
+WHAT IT IS
+
+  It's a tool for automatically creating the basic framework for a PHP module
+  and writing C code handling arguments passed to your functions from a simple
+  configuration file. See an example at the end of this file.
+
+HOW TO USE IT
+
+  Very simple. First, cd do directory ext/ in PHP 4 sources. If you just need
+  the basic framework and will be writing all the code in your functions
+  yourself, you can now do
+
+   ./ext_skel --extname=module_name
+
+  and everything you need is placed in directory module_name. In fact, if you
+  don't need to test the existence of any external header files, libraries or
+  functions in them, the module is already almost ready to be compiled in PHP.
+  Just remove 3 comments in your_module_name/config.m4, cd back up to PHP
+  sources top directory, and do
+
+    ./buildconf; ./configure --enable-module_name; make
+
+  But if you already have planned the overall scheme of your module, what
+  functions it will contain, their return types and the arguments they take
+  (a very good idea) and don't want to bother yourself with creating function
+  definitions and handling arguments passed yourself, it's time to create a
+  function definitions file, which you will give as an argument to ext_skel
+  with option
+
+    --proto=filename.
+
+FORMAT OF FUNCTION DEFINITIONS FILE
+
+  All the definitions must be on one line. In it's simplest form, it's just
+  the function name, ie.
+
+    my_function
+
+  but then you'll be left with an almost empty function body without any
+  argument handling.
+
+  Arguments are given in parenthesis after the function name, and are of
+  the form 'argument_type argument_name'. Arguments are separated from each
+  other with a comma and optional space. Argument_type can be one of int,
+  bool, double, float, string, array, object or mixed.
+
+  An optional argument is separated from the previous by an optional space,
+  then '[' and of course comma and optional space, like all the other
+  arguments. You should close a row of optional arguments with same amount of
+  ']'s as there where '['s. Currently, it does not harm if you forget to do it
+  or there is a wrong amount of ']'s, but this may change in the future.
+
+  An example:
+
+    my_function(int arg1, int arg2 [, int arg3 [, int arg4]])
+
+  Arguments arg3 and arg4 are optional.
+
+  If possible, the function definition should also contain it's return type
+  in front of the definition. It's not actually used for any C code generating
+  purposes but PHP in-source documentation instead, and as such, very useful.
+  It can be any of int, double, string, bool, array, object, resource, mixed
+  or void.
+
+  The file must contain nothing else but function definitions, no comments or
+  empty lines.
+
+OTHER OPTIONS
+
+    --no-help
+
+  By default, ext_skel creates both comments in the source code and a test
+  function to help first time module writers to get started and testing
+  configuring and compiling their module. This option turns off all such things
+  which may just annoy experienced PHP module coders. Especially useful with
+
+    --stubs=file
+
+  which will leave out also all module specific stuff and write just function
+  stubs with function value declarations and passed argument handling, and
+  function entries and definitions at the end of the file, for copying and
+  pasting into an already existing module.
+
+    --assign-params
+    --string-lens
+
+  By default, function proto 'void foo(string bar)' creates the following:
+     ...
+     zval **bar;
+     ... (zend_get_parameters_ex() called in the middle...)
+     convert_to_string_ex(bar);
+
+  Specifying both of these options changes the generated code to:
+     ...
+     zval **bar_arg;
+     int bar_len;
+     char *bar = NULL;
+     ... (zend_get_parameters_ex() called in the middle...)
+     convert_to_string_ex(bar_arg);
+     bar = Z_STRVAL_PP(bar_arg);
+     bar_len = Z_STRLEN_PP(bar_arg);
+
+  You shouldn't have to ask what happens if you leave --string-lens out. If you
+  have to, it's questionable whether you should be reading this document.
+
+    --with-xml[=file]
+
+  Creates the basics for phpdoc .xml file.
+
+    --full-xml
+
+  Not implemented yet. When or if there will ever be created a framework for
+  self-contained extensions to use phpdoc system for their documentation, this
+  option enables it on the created xml file.
+
+CURRENT LIMITATIONS, BUGS AND OTHER ODDITIES
+
+  Only arguments of types int, bool, double, float, string and array are
+  handled. For other types you must write the code yourself. And for type
+  mixed, it wouldn't even be possible to write anything, because only you
+  know what to expect.
+  
+  It can't handle correctly, and probably never will, variable list of
+  of arguments. (void foo(int bar [, ...])
+
+  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.
+
+  This program doesn't have a --help option. It has --no-help instead.
+
+EXAMPLE
+
+  The following _one_ line
+
+  bool my_drawtext(resource image, string text, resource font, int x, int y [, int color])
+
+  will create this function definition for you (note that there are a few
+  question marks to be replaced by you, and you must of course add your own
+  value definitions too):
+
+/* {{{ proto bool my_drawtext(resource image, string text, resource font, int x, int y[, int color])
+    */
+PHP_FUNCTION(my_drawtext)
+{
+	zval **image, **text, **font, **x, **y, **color;
+	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, "???", ???G());
+	ZEND_FETCH_RESOURCE(???, ???, font, font_id, "???", ???G());
+
+	switch (argc) {
+		case 6:
+			convert_to_long_ex(color);
+			/* Fall-through. */
+		case 5:
+			convert_to_long_ex(y);
+			convert_to_long_ex(x);
+			/* font: fetching resources already handled. */
+			convert_to_string_ex(text);
+			/* image: fetching resources already handled. */
+			break;
+		default:
+			WRONG_PARAM_COUNT;
+	}
+
+	php_error(E_WARNING, "my_drawtext: not yet implemented");
+}
+/* }}} */
+

README.QNX

@@ -0,0 +1,57 @@
+QNX4 Installation Notes
+-----------------------
+
+NOTE: General installation instructions are in the INSTALL file 
+
+
+1. To compile and test PHP3 you have to grab, compile and install:
+	- GNU dbm library or another db library;
+	- GNU bison (1.25 or later; 1.25 tested);
+	- GNU flex (any version supporting -o and -P options; 2.5.4 tested);
+	- GNU diffutils (any version supporting -w option; 2.7 tested);
+
+2. To use CVS version you may need also:
+	- GNU CVS (1.9 tested);
+	- GNU autoconf (2.12 tested);
+	- GNU m4 (1.3 or later preferable; 1.4 tested);
+
+3. To run configure define -lunix in command line:
+	LDFLAGS=-lunix ./configure
+
+4. To use Sybase SQL Anywhere define ODBC_QNX and CUSTOM_ODBC_LIBS in
+	command line and run configure with --with-custom-odbc:
+	CFLAGS=-DODBC_QNX LDFLAGS=-lunix CUSTOM_ODBC_LIBS="-ldblib -lodbc" ./configure --with-custom-odbc=/usr/lib/sqlany50
+   If you have SQL Anywhere version 5.5.00, then you have to add 
+	CFLAGS=-DSQLANY_BUG
+   to workaround its SQLFreeEnv() bug. Other versions has not been tested,
+   so try without this flag first.
+
+5. To build the Apache module, you may have to hardcode an include path for 
+   alloc.h in your Apache base directory:
+	- APACHE_DIRECTORY/src/httpd.h: 
+		change	#include "alloc.h"
+		to 		#include "APACHE_DIRECTORY/src/alloc.h"
+   Unless you want to use system regex library, you have to hardcode also
+   a path to regex.h:
+	- APACHE_DIRECTORY/src/conf.h:  
+		change  #include <regex.h>
+		to		#include "APACHE_DIRECTORY/src/regex/regex.h"
+   I don't know so far why this required for QNX, may be it is Watcom 
+   compiler problem.
+
+  If you building Apache module with SQL Anywhere support, you'll get
+  symbol conflict with BOOL. It is defined in Apache (httpd.h) and in 
+  SQL Anywhere (odbc.h). This has nothing to do with PHP, so you have to 
+  fix it yourself someway.
+
+6. With above precautions, it should compile as is and pass regression
+	tests completely:
+		make
+		make check
+		make install
+
+	Don't bother me unless you really sure you made	that all but it 
+	still doesn't work.
+
+June 28, 1998
+Igor Kovalenko -- owl@infomarket.ru

README.SELF-CONTAINED-EXTENSIONS

@@ -0,0 +1,174 @@
+$Id$
+=============================================================================
+
+HOW TO CREATE A SELF-CONTAINED PHP EXTENSION
+
+  A self-contained extension can be distributed independently of
+  the PHP source. To create such an extension, three things are
+  required:
+
+  - Makefile template (Makefile.in)
+  - Configuration file (config.m4)
+  - Source code for your module
+
+  We will describe now how to create these and how to put things
+  together.
+
+PREPARING YOUR SYSTEM
+
+  While the result will run on any system, a developer's setup needs these
+  tools:
+
+    GNU autoconf
+    GNU automake
+    GNU libtool
+    GNU m4
+
+  All of these are available from 
+
+    ftp://ftp.gnu.org/pub/gnu/
+
+CONVERTING AN EXISTING EXTENSION
+
+  Just to show you how easy it is to create a self-contained
+  extension, we will convert an embedded extension into a
+  self-contained one. Install PHP and execute the following
+  commands.
+  
+     $ mkdir /tmp/newext
+     $ cd /tmp/newext
+
+  You now have an empty directory. We will copy the files from
+  the mysql extension:
+
+     $ cp -rp php-4.0.X/ext/mysql/* .
+
+  It is time to finish the module. Run:
+
+     $ phpize
+
+  You can now ship the contents of the directory - the extension
+  can live completely on its own.
+
+  The user instructions boil down to
+
+     $ ./configure \
+            [--with-php-config=/path/to/php-config] \
+            [--with-mysql=MYSQL-DIR]
+     $ make install
+
+  The MySQL module will either use the embedded MySQL client 
+  library or the MySQL installation in MYSQL-DIR.
+
+
+DEFINING THE NEW EXTENSION
+
+  Our demo extension is called "foobar".
+
+  It consists of two source files "foo.c" and "bar.c"
+  (and any arbitrary amount of header files, but that is not
+  important here).
+  
+  The demo extension does not reference any external 
+  libraries (that is important, because the user does not
+  need to specify anything).
+
+
+CREATING THE MAKEFILE TEMPLATE 
+  
+  The Makefile Template (Makefile.in) contains three lines:
+
+------------------------------------------------------------------------------
+LTLIBRARY_SHARED_NAME = foobar.la
+LTLIBRARY_SOURCES     = foo.c bar.c
+
+include $(top_srcdir)/build/dynlib.mk
+------------------------------------------------------------------------------
+
+  LTLIBRARY_SHARED_NAME specifies the name of the extension.
+  It must be of the form `ext-name.la'.
+
+  LTLIBRARY_SOURCES specifies the names of the sources files. You can
+  name an arbitrary number of source files here.
+
+  The final include directive includes the build rules (you usually
+  don't need to care about what happens there). rules.mk and other
+  files are installed by phpize which we will cover later.
+
+
+CREATING THE M4 CONFIGURATION FILE
+
+  The m4 configuration can perform additional checks. For a 
+  self-contained extension, you do not need more than a few
+  macro calls.
+
+------------------------------------------------------------------------------
+PHP_ARG_ENABLE(foobar,whether to enable foobar,
+[  --enable-foobar            Enable foobar])
+
+if test "$PHP_FOOBAR" != "no"; then
+  PHP_EXTENSION(foobar, $ext_shared)
+fi
+------------------------------------------------------------------------------
+
+  PHP_ARG_ENABLE will automatically set the correct variables, so
+  that the extension will be enabled by PHP_EXTENSION in shared mode.
+
+  Please use always PHP_ARG_ENABLE or PHP_ARG_WITH. Even if you do not
+  plan to distribute your module with PHP, these facilities allow you
+  to integrate your module easily into the main PHP module framework.
+
+CREATING SOURCE FILES
+
+  ext_skel can be of great help when creating the common code for all modules
+  in PHP for you and also writing basic function definitions and C code for
+  handling arguments passed to your functions. See README.EXT_SKEL for further
+  information.
+
+  As for the rest, you are currently alone here. There are a lot of existing
+  modules, use a simple module as a starting point and add your own code.
+
+
+CREATING THE SELF-CONTAINED EXTENSION
+
+  Put Makefile.in, config.m4 and the source files into one directory.
+  Then run phpize (this is installed during make install by PHP 4.0).
+  For example, if you configured PHP with --prefix=/php, you would run
+
+     $ /php/bin/phpize
+
+  This will automatically copy the necessary build files and create
+  configure from your config.m4.
+
+  And that's it. You now have a self-contained extension.
+
+INSTALLING A SELF-CONTAINED EXTENSION
+
+  An extension can be installed by running:
+
+     $ ./configure \
+            [--with-php-config=/path/to/php-config]
+     $ make install
+
+ADDING SHARED MODULE SUPPORT TO A MODULE
+
+  In order to be useful, a self-contained extension must be loadable
+  as a shared module. I will explain now how you can add shared module 
+  support to an existing module called foo.
+
+  1. In config.m4, use PHP_ARG_WITH/PHP_ARG_ENABLE. Then you will
+     automatically be able to use --with-foo=shared or
+     --enable-foo=shared.
+
+  2. In config.m4, use PHP_EXTENSION(foo, $ext_shared) to enable
+     building the extension.
+
+  3. Add the following line to Makefile.in:
+
+        LTLIBRARY_SHARED_NAME = foo.la
+
+  4. Add the following lines to your C source file:
+
+        #ifdef COMPILE_DL_FOO
+        ZEND_GET_MODULE(foo)
+        #endif

README.Zeus

@@ -0,0 +1,102 @@
+Using PHP4 with the Zeus Web Server
+-----------------------------------
+
+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.
+
+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.
+
+
+To build the ISAPI version of PHP, start the configuration with:
+
+./configure --with-zeus=/usr/local/zeus
+
+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.
+
+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
+-------------------------
+
+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:
+
+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!
+
+
+Troubleshooting
+---------------
+
+*) Why does the compile fail at Zend/zend-scanner-cc.cc
+                             or Zend/zend-parser.c ?
+
+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:
+
+       bison  1.28 or later
+       flex  2.5.4 or later
+
+*) Why does my PHP library fail to load?
+
+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.
+
+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.)
+
+Specific examples:
+
+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)
+
+FreeBSD 4.0:
+Some people may find they need to run ./configure with the
+'--enable-libgcc' compile option too.
+
+
+For more information and help with Zeus, please visit our website:
+http://www.zeus.com

TODO

@@ -0,0 +1,109 @@
+Things to do or at least think about doing in the future. Name in
+parenthesis means that person has taken on this project.
+
+Zend
+----
+    * allow foreach ($array as $k => &$val) syntax. right now we cannot 
+      traverse an array without copying each element.
+    * look at replacing c-lib call tolower().
+    * make hash API functions work with HASH_OF() to save time.
+
+global
+------
+    * 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/dav/dav.c, ext/db/db.c, ext/gd/gd.c, ext/ldap/ldap.c
+    * INI system causes segfaults in ZTS mode (operates on static HashTable)
+    * 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
+      dependices. (eg ftp)
+    * --enable-all in configure. (--enable-shared=max ...)
+    * make configure print out a summary when it's done (like XEmacs)
+    * replace standard functions which work on static data with 
+      reentrancy-safe functions.
+    * on some platforms unimplemented function will just do nothing (e.g. symlink)
+      they should print a warning or not even be defined!
+    * implement javadoc based function docs template system.
+    * use thread-safe resolver functions (either require BIND 8 or adns).
+    * provide optional IPv6 support.
+    * make SAPI conform to CGI/1.1. Currently, all SAPI modules
+      define REMOTE_ADDR etc. themselves and reach only various level
+      of compliance.
+    * find a better way to implement script timeouts. SIGVTALRM is used
+      by some POSIX threads implementations (i.e. OpenBSD) and is not
+      available in ZTS mode.
+    * add aliases to functions to conform to new naming conventions, e.g.
+      str_to_upper().
+    * see what functions might need to be changed to use HashPosition, so
+      that the internal array pointer is not affected.
+
+documentation
+-------------
+    * add remarks in the documentation which functions are not implemented on win32.
+    * add remarks in the documentation which functions are not binary-safe.
+
+ext/dav
+--------
+    * rewrite.
+
+ext/mcrypt
+----------
+    * port to mcrypt-2.6 or later
+
+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.
+
+ext/pcre
+--------
+    * have an option for preg_grep() to return keys as well.
+    * 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
+
+ext/standard
+------------
+    * 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.
+    * strcase_replace(). (Andrei)
+    * move socket related functions to fsock.c.
+    * get_defined_funcs(), get_defined_vars().
+    * NOT binary safe:
+        strtok()
+        basename()
+        dirname()
+        strrpos()
+        strrchr()
+        strip_tags()
+
+ext/wddx
+--------
+    * See if we can support the remaining datatypes:
+        dateTime
+        binary
+        recordset
+
+        http://www.wddx.org/WDDX_SDK_10a/7__References/WDDX_DTD.htm
+        (Andrei)
+
+    * implement wddx_packet_as_javascript(). (Andrei)
+
+other cool stuff
+----------------
+    * PVM extension

TSRM/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 1999, 2000, Andi Gutmans, Sascha Schumann, Zeev Suraski.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+- Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+
+- Neither name of the copyright holders nor the names of their contributors
+may be used to endorse or promote products derived from this software
+without specific prior written permission.
+
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
+IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

TSRM/Makefile.am

@@ -0,0 +1,6 @@
+## process this file with automake to produce Makefile.am
+AUTOMAKE_OPTIONS=foreign
+noinst_LTLIBRARIES=libtsrm.la
+libtsrm_la_SOURCES = TSRM.c tsrm_strtok_r.c tsrm_virtual_cwd.c
+
+depend:

TSRM/TODO

@@ -0,0 +1,2 @@
+- Improve the lock in ts_resource_ex() in order to cover less code.
+  This can probably be done by more careful hash table access

TSRM/TSRM.c

@@ -0,0 +1,462 @@
+/*
+   +----------------------------------------------------------------------+
+   | Thread Safe Resource Manager                                         |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1999, 2000, Andi Gutmans, Sascha Schumann, Zeev Suraski|
+   | This source file is subject to the TSRM license, that is bundled     |
+   | with this package in the file LICENSE                                |
+   +----------------------------------------------------------------------+
+   | Authors:  Zeev Suraski <zeev@zend.com>                               |
+   +----------------------------------------------------------------------+
+*/
+
+#include "TSRM.h"
+
+#ifdef ZTS
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#if HAVE_STDARG_H
+#include <stdarg.h>
+#endif
+
+typedef struct _tsrm_tls_entry tsrm_tls_entry;
+
+struct _tsrm_tls_entry {
+	void **storage;
+	int count;
+	THREAD_T thread_id;
+	tsrm_tls_entry *next;
+};
+
+
+typedef struct {
+	size_t size;
+	ts_allocate_ctor ctor;
+	ts_allocate_dtor dtor;
+} tsrm_resource_type;
+
+
+/* The memory manager table */
+static tsrm_tls_entry	**tsrm_tls_table;
+static int				tsrm_tls_table_size;
+static ts_rsrc_id		id_count;
+
+/* The resource sizes table */
+static tsrm_resource_type	*resource_types_table;
+static int					resource_types_table_size;
+
+
+static MUTEX_T tsmm_mutex;	/* thread-safe memory manager mutex */
+
+/* New thread handlers */
+static void (*tsrm_new_thread_begin_handler)();
+static void (*tsrm_new_thread_end_handler)();
+
+/* Debug support */
+static int tsrm_debug(const char *format, ...);
+static int tsrm_debug_status;
+
+
+/* Startup TSRM (call once for the entire process) */
+TSRM_API int tsrm_startup(int expected_threads, int expected_resources, int debug_status)
+{
+#if defined(GNUPTH)
+	pth_init();
+#endif
+
+	tsrm_tls_table_size = expected_threads;
+	tsrm_tls_table = (tsrm_tls_entry **) calloc(tsrm_tls_table_size, sizeof(tsrm_tls_entry *));
+	if (!tsrm_tls_table) {
+		return 0;
+	}
+	id_count=0;
+
+	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) {
+		free(tsrm_tls_table);
+		return 0;
+	}
+
+	tsmm_mutex = tsrm_mutex_alloc();
+
+	tsrm_new_thread_begin_handler = tsrm_new_thread_end_handler = NULL;
+
+	tsrm_debug_status = debug_status;
+
+	tsrm_debug("Started up TSRM, %d expected threads, %d expected resources\n", expected_threads, expected_resources);
+	return 1;
+}
+
+
+/* Shutdown TSRM (call once for the entire process) */
+TSRM_API void tsrm_shutdown(void)
+{
+	int i;
+
+	if (tsrm_tls_table) {
+		for (i=0; i<tsrm_tls_table_size; i++) {
+			tsrm_tls_entry *p = tsrm_tls_table[i], *next_p;
+
+			while (p) {
+				int j;
+
+				next_p = p->next;
+				for (j=0; j<id_count; j++) {
+					free(p->storage[j]);
+				}
+				free(p->storage);
+				free(p);
+				p = next_p;
+			}
+		}
+		free(tsrm_tls_table);
+	}
+	if (resource_types_table) {
+		free(resource_types_table);
+	}
+	tsrm_mutex_free(tsmm_mutex);
+	tsrm_debug("Shutdown TSRM\n");
+#if defined(GNUPTH)
+	pth_kill();
+#endif
+}
+
+
+/* allocates a new thread-safe-resource id */
+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_debug("Obtaining a new resource id, %d bytes\n", size);
+
+	tsrm_mutex_lock(tsmm_mutex);
+
+	/* obtain a resource id */
+	new_id = id_count++;
+	tsrm_debug("Obtained resource id %d\n", 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) {
+			return -1;
+		}
+		resource_types_table_size = id_count;
+	}
+	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++) {
+		tsrm_tls_entry *p = tsrm_tls_table[i];
+
+		while (p) {
+			if (p->count < id_count) {
+				int j;
+
+				p->storage = (void *) realloc(p->storage, sizeof(void *)*id_count);
+				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->count = id_count;
+			}
+			p = p->next;
+		}
+	}
+	tsrm_mutex_unlock(tsmm_mutex);
+
+	tsrm_debug("Successfully allocated new resource id %d\n", new_id);
+	return new_id;
+}
+
+
+static void allocate_new_resource(tsrm_tls_entry **thread_resources_ptr, THREAD_T thread_id)
+{
+	int i;
+
+	(*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;
+
+	tsrm_mutex_unlock(tsmm_mutex);
+
+	if (tsrm_new_thread_begin_handler) {
+		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]);
+		}
+	}
+	if (tsrm_new_thread_end_handler) {
+		tsrm_new_thread_end_handler(thread_id);
+	}
+}
+
+
+/* fetches the requested resource for the current thread */
+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) {
+		thread_id = *th_id;
+	} else {
+		thread_id = tsrm_thread_id();
+	}
+	tsrm_debug("Fetching resource id %d for thread %ld\n", id, (long) thread_id);
+	tsrm_mutex_lock(tsmm_mutex);
+
+	hash_value = THREAD_HASH_OF(thread_id, tsrm_tls_table_size);
+	thread_resources = tsrm_tls_table[hash_value];
+
+	if (!thread_resources) {
+		allocate_new_resource(&tsrm_tls_table[hash_value], thread_id);
+		return ts_resource(id);
+		/* thread_resources = tsrm_tls_table[hash_value]; */
+	} else {
+		 do {
+			if (thread_resources->thread_id == thread_id) {
+				break;
+			}
+			if (thread_resources->next) {
+				thread_resources = thread_resources->next;
+			} else {
+				allocate_new_resource(&thread_resources->next, thread_id);
+				return ts_resource(id);
+				/*
+				 * thread_resources = thread_resources->next;
+				 * break;
+				 */
+			}
+		 } while (thread_resources);
+	}
+
+	resource = thread_resources->storage[id];
+
+	tsrm_mutex_unlock(tsmm_mutex);
+
+	tsrm_debug("Successfully fetched resource id %d for thread id %ld - %x\n", id, (long) thread_id, (long) resource);
+	return resource;
+}
+
+
+/* frees all resources allocated for the current thread */
+void ts_free_thread(void)
+{
+	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);
+	hash_value = THREAD_HASH_OF(thread_id, tsrm_tls_table_size);
+	thread_resources = tsrm_tls_table[hash_value];
+
+	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]);
+				}
+				free(thread_resources->storage[i]);
+			}
+			free(thread_resources->storage);
+			if (last) {
+				last->next = thread_resources->next;
+			} else {
+				tsrm_tls_table[hash_value]=NULL;
+			}
+			free(thread_resources);
+			break;
+		}
+		if (thread_resources->next) {
+			last = thread_resources;
+		}
+		thread_resources = thread_resources->next;
+	}
+	tsrm_mutex_unlock(tsmm_mutex);
+}
+
+
+/* deallocates all occurrences of a given id */
+void ts_free_id(ts_rsrc_id id)
+{
+}
+
+
+
+
+/*
+ * Utility Functions
+ */
+
+/* Obtain the current thread id */
+TSRM_API THREAD_T tsrm_thread_id(void)
+{
+#ifdef TSRM_WIN32
+	return GetCurrentThreadId();
+#elif defined(GNUPTH)
+	return pth_self();
+#elif defined(PTHREADS)
+	return pthread_self();
+#elif defined(NSAPI)
+	return systhread_current();
+#elif defined(PI3WEB)
+	return PIThread_getCurrent();
+#endif
+}
+
+
+/* Allocate a mutex */
+TSRM_API MUTEX_T tsrm_mutex_alloc( void )
+{
+    MUTEX_T mutexp;
+
+#ifdef TSRM_WIN32
+    mutexp = malloc(sizeof(CRITICAL_SECTION));
+	InitializeCriticalSection(mutexp);
+#elif defined(GNUPTH)
+	mutexp = (MUTEX_T) malloc(sizeof(*mutexp));
+	pth_mutex_init(mutexp);
+#elif defined(PTHREADS)
+	mutexp = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t));
+	pthread_mutex_init(mutexp,NULL);
+#elif defined(NSAPI)
+	mutexp = crit_init();
+#elif defined(PI3WEB)
+	mutexp = PIPlatform_allocLocalMutex();
+#endif
+#ifdef THR_DEBUG
+		printf("Mutex created thread: %d\n",mythreadid());
+#endif
+    return( mutexp );
+}
+
+
+/* Free a mutex */
+TSRM_API void tsrm_mutex_free( MUTEX_T mutexp )
+{
+    if (mutexp) {
+#ifdef TSRM_WIN32
+		DeleteCriticalSection(mutexp);
+#elif defined(GNUPTH)
+		free(mutexp);
+#elif defined(PTHREADS)
+		pthread_mutex_destroy(mutexp);
+		free(mutexp);
+#elif defined(NSAPI)
+		crit_terminate(mutexp);
+#elif defined(PI3WEB)
+		PISync_delete(mutexp) 
+#endif
+    }
+#ifdef THR_DEBUG
+		printf("Mutex freed thread: %d\n",mythreadid());
+#endif
+}
+
+
+/* Lock a mutex */
+TSRM_API int tsrm_mutex_lock( MUTEX_T mutexp )
+{
+#if 0
+	tsrm_debug("Mutex locked thread: %ld\n",tsrm_thread_id());
+#endif
+#ifdef TSRM_WIN32
+	EnterCriticalSection(mutexp);
+	return 1;
+#elif defined(GNUPTH)
+	return pth_mutex_acquire(mutexp, 0, NULL);
+#elif defined(PTHREADS)
+	return pthread_mutex_lock(mutexp);
+#elif defined(NSAPI)
+	return crit_enter(mutexp);
+#elif defined(PI3WEB)
+	return PISync_lock(mutexp);
+#endif
+}
+
+
+/* Unlock a mutex */
+TSRM_API int tsrm_mutex_unlock( MUTEX_T mutexp )
+{
+#if 0
+	tsrm_debug("Mutex unlocked thread: %ld\n",tsrm_thread_id());
+#endif
+#ifdef TSRM_WIN32
+	LeaveCriticalSection(mutexp);
+	return 1;
+#elif defined(GNUPTH)
+	return pth_mutex_release(mutexp);
+#elif defined(PTHREADS)
+	return pthread_mutex_unlock(mutexp);
+#elif defined(NSAPI)
+	return crit_exit(mutexp);
+#elif defined(PI3WEB)
+	return PISync_unlock(mutexp);
+#endif
+}
+
+
+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;
+
+	tsrm_new_thread_begin_handler = new_thread_begin_handler;
+	return retval;
+}
+
+
+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_new_thread_end_handler = new_thread_end_handler;
+	return retval;
+}
+
+
+
+/*
+ * Debug support
+ */
+
+static int tsrm_debug(const char *format, ...)
+{
+	if (tsrm_debug_status) {
+		va_list args;
+		int size;
+
+		va_start(args, format);
+		size = vprintf(format, args);
+		va_end(args);
+		return size;
+	} else {
+		return 0;
+	}
+}
+
+
+void tsrm_debug_set(int status)
+{
+	tsrm_debug_status = status;
+}
+
+#endif /* ZTS */

TSRM/TSRM.dsp

@@ -0,0 +1,149 @@
+# Microsoft Developer Studio Project File - Name="TSRM" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=TSRM - Win32 Debug_TS
+!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 "TSRM.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 "TSRM.mak" CFG="TSRM - Win32 Debug_TS"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!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 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "TSRM - Win32 Debug_TS"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "TSRM___Win32_Debug_TS"
+# PROP BASE Intermediate_Dir "TSRM___Win32_Debug_TS"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug_TS"
+# PROP Intermediate_Dir "Debug_TS"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /I "C:\Projects\TSRM" /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 "ZTS" /D "_LIB" /D "TSRM_EXPORTS" /D "WIN32" /D "_MBCS" /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)" == "TSRM - Win32 Release_TS"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "TSRM___Win32_Release_TS"
+# PROP BASE Intermediate_Dir "TSRM___Win32_Release_TS"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 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" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "." /D "NDEBUG" /D "ZTS" /D "_LIB" /D "TSRM_EXPORTS" /D "WIN32" /D "_MBCS" /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
+
+!ELSEIF  "$(CFG)" == "TSRM - Win32 Release_TS_inline"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "TSRM___Win32_Release_TS_inline"
+# PROP BASE Intermediate_Dir "TSRM___Win32_Release_TS_inline"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 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" /D "WIN32" /D "_MBCS" /D "_LIB" /D "TSRM_EXPORTS" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "." /D "NDEBUG" /D "ZTS" /D "_LIB" /D "TSRM_EXPORTS" /D "WIN32" /D "_MBCS" /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
+
+# Name "TSRM - Win32 Debug_TS"
+# Name "TSRM - Win32 Release_TS"
+# Name "TSRM - 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=.\TSRM.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\tsrm_strtok_r.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\tsrm_virtual_cwd.c
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=.\TSRM.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\tsrm_config.w32.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\tsrm_config_common.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\tsrm_strtok_r.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\tsrm_virtual_cwd.h
+# End Source File
+# End Group
+# End Target
+# End Project

TSRM/TSRM.h

@@ -0,0 +1,116 @@
+/*
+   +----------------------------------------------------------------------+
+   | Thread Safe Resource Manager                                         |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1999, 2000, Andi Gutmans, Sascha Schumann, Zeev Suraski|
+   | This source file is subject to the TSRM license, that is bundled     |
+   | with this package in the file LICENSE                                |
+   +----------------------------------------------------------------------+
+   | Authors:  Zeev Suraski <zeev@zend.com>                               |
+   +----------------------------------------------------------------------+
+*/
+
+#ifndef TSRM_H
+#define TSRM_H
+
+#ifdef HAVE_CONFIG_H
+# undef PACKAGE
+# undef VERSION
+# include "tsrm_config.h"
+# undef PACKAGE
+# undef VERSION
+#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)
+#	else
+#	define TSRM_API __declspec(dllimport)
+#	endif
+#else
+#	define TSRM_API
+#endif
+
+
+/* Define THREAD_T and MUTEX_T */
+#ifdef TSRM_WIN32
+# define THREAD_T DWORD
+# define MUTEX_T CRITICAL_SECTION *
+#elif defined(GNUPTH)
+# define THREAD_T pth_t
+# define MUTEX_T pth_mutex_t *
+#elif defined(PTHREADS)
+# define THREAD_T pthread_t
+# define MUTEX_T pthread_mutex_t *
+#elif defined(NSAPI)
+# define THREAD_T SYS_THREAD
+# define MUTEX_T CRITICAL
+#elif defined(PI3WEB)
+# define THREAD_T PIThread *
+# define MUTEX_T PISync *
+#endif
+
+typedef void (*ts_allocate_ctor)(void *);
+typedef void (*ts_allocate_dtor)(void *);
+
+#define THREAD_HASH_OF(thr,ts)  (unsigned long)thr%(unsigned long)ts
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* startup/shutdown */
+TSRM_API int tsrm_startup(int expected_threads, int expected_resources, int debug_status);
+TSRM_API void tsrm_shutdown(void);
+
+/* allocates a new thread-safe-resource id */
+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);
+#define ts_resource(id)			ts_resource_ex(id, NULL)
+
+/* frees all resources allocated for the current thread */
+TSRM_API void ts_free_thread(void);
+
+/* deallocates all occurrences of a given id */
+TSRM_API void ts_free_id(ts_rsrc_id id);
+
+
+/* Debug support */
+TSRM_API void tsrm_debug_set(int status);
+
+/* utility functions */
+TSRM_API THREAD_T tsrm_thread_id(void);
+TSRM_API MUTEX_T tsrm_mutex_alloc(void);
+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(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
+
+#endif /* ZTS */
+
+#endif /* TSRM_H */

TSRM/acconfig.h

@@ -0,0 +1 @@
+#undef PTHREADS

TSRM/acinclude.m4

@@ -0,0 +1,5 @@
+
+AC_DEFUN(AM_SET_LIBTOOL_VARIABLE,[
+  LIBTOOL='$(SHELL) $(top_builddir)/libtool $1'
+])
+

TSRM/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 = tsrm_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

TSRM/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
+

TSRM/configure.in

@@ -0,0 +1,33 @@
+dnl $Id$
+dnl
+dnl Minimalistic configure.in for TSRM.
+dnl
+
+AC_INIT(TSRM.c)
+AM_INIT_AUTOMAKE(TSRM, 1.0)
+AM_CONFIG_HEADER(tsrm_config.h)
+
+sinclude(tsrm.m4)
+	
+TSRM_BASIC_CHECKS
+TSRM_THREADS_CHECKS
+	
+AM_PROG_LIBTOOL
+if test "$enable_debug" != "yes"; then
+  AM_SET_LIBTOOL_VARIABLE([--silent])
+fi
+
+dnl TSRM_PTHREAD
+
+AC_CHECK_HEADERS(
+utime.h \
+dirent.h \
+stdarg.h \
+alloca.h \
+unistd.h \
+limits.h
+)
+
+AC_DEFINE(ZTS,1,[ ])
+
+AC_OUTPUT(Makefile)

TSRM/readdir.h

@@ -0,0 +1,44 @@
+#ifndef READDIR_H
+#define READDIR_H
+
+
+/*
+ * Structures and types used to implement opendir/readdir/closedir
+ * on Windows 95/NT.
+ */
+
+#include <io.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+
+
+/* struct dirent - same as Unix */
+
+struct dirent {
+	long d_ino;					/* inode (always 1 in WIN32) */
+	off_t d_off;				/* offset to this dirent */
+	unsigned short d_reclen;	/* length of d_name */
+	char d_name[_MAX_FNAME + 1];	/* filename (null terminated) */
+};
+
+
+/* typedef DIR - not the same as Unix */
+typedef struct {
+	long handle;				/* _findfirst/_findnext handle */
+	short offset;				/* offset into directory */
+	short finished;				/* 1 if there are not more files */
+	struct _finddata_t fileinfo;	/* from _findfirst/_findnext */
+	char *dir;					/* the dir we are reading */
+	struct dirent dent;			/* the dirent to return */
+} DIR;
+
+/* Function prototypes */
+DIR *opendir(const char *);
+struct dirent *readdir(DIR *);
+int readdir_r(DIR *, struct dirent *, struct dirent **);
+int closedir(DIR *);
+void rewinddir(DIR *);
+
+
+#endif /* READDIR_H */

TSRM/threads.m4

@@ -0,0 +1,157 @@
+dnl  Copyright (c) 1999, 2000 Sascha Schumann. All rights reserved.
+dnl 
+dnl  Redistribution and use in source and binary forms, with or without
+dnl  modification, are permitted provided that the following conditions
+dnl  are met:
+dnl 
+dnl  1. Redistributions of source code must retain the above copyright
+dnl     notice, this list of conditions and the following disclaimer.
+dnl 
+dnl  2. Redistributions in binary form must reproduce the above copyright
+dnl     notice, this list of conditions and the following disclaimer in
+dnl     the documentation and/or other materials provided with the
+dnl     distribution.
+dnl 
+dnl  THIS SOFTWARE IS PROVIDED BY SASCHA SCHUMANN ``AS IS'' AND ANY
+dnl  EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+dnl  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+dnl  PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL SASCHA SCHUMANN OR
+dnl  HIS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+dnl  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+dnl  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+dnl  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+dnl  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+dnl  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+dnl  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+dnl  OF THE POSSIBILITY OF SUCH DAMAGE.
+
+dnl
+dnl PTHREADS_FLAGS
+dnl
+dnl Set some magic defines to achieve POSIX threads conformance
+dnl
+AC_DEFUN(PTHREADS_FLAGS,[
+  if test -z "$host_alias"; then
+    AC_MSG_ERROR(host_alias is not set. Make sure to run config.guess)
+  fi
+  case "$host_alias" in
+  *solaris*)
+    PTHREAD_FLAGS="-D_POSIX_PTHREAD_SEMANTICS -D_REENTRANT";;
+  *freebsd*)
+    PTHREAD_FLAGS="-D_REENTRANT -D_THREAD_SAFE";;
+  *linux*)
+    PTHREAD_FLAGS="-D_REENTRANT";;
+  *aix*)
+    PTHREAD_FLAGS="-D_THREAD_SAFE";;
+  *irix*)
+    PTHREAD_FLAGS="-D_POSIX_THREAD_SAFE_FUNCTIONS";;
+  *hpux*)
+    PTHREAD_FLAGS="-D_REENTRANT";;
+  *sco*)
+    PTHREAD_FLAGS="-D_REENTRANT";;
+dnl Solves sigwait() problem, creates problems with u_long etc.
+dnl    PTHREAD_FLAGS="-D_REENTRANT -D_XOPEN_SOURCE=500 -D_POSIX_C_SOURCE=199506 -D_XOPEN_SOURCE_EXTENDED=1";;
+  esac
+
+  if test -n "$PTHREAD_FLAGS"; then
+    CPPFLAGS="$CPPFLAGS $PTHREAD_FLAGS"
+  fi
+])dnl
+dnl
+dnl PTHREADS_CHECK_COMPILE
+dnl
+dnl Check whether the current setup can use POSIX threads calls
+dnl
+AC_DEFUN(PTHREADS_CHECK_COMPILE, [
+AC_TRY_RUN( [
+#include <pthread.h>
+#include <stddef.h>
+
+void *thread_routine(void *data) {
+    return data;
+}
+
+int main() {
+    pthread_t thd;
+    pthread_mutexattr_t mattr;
+    int data = 1;
+    pthread_mutexattr_init(&mattr);
+    return pthread_create(&thd, NULL, thread_routine, &data);
+} ], [ 
+  pthreads_working="yes"
+  ], [
+  pthreads_working="no"
+  ], pthreads_working="no" ) ] )dnl
+dnl
+dnl PTHREADS_CHECK()
+dnl
+dnl Try to find a way to enable POSIX threads
+dnl
+dnl  Magic flags
+dnl  -kthread          gcc (FreeBSD)
+dnl  -Kthread          UDK cc (UnixWare)
+dnl  -mt               WorkShop cc (Solaris)
+dnl  -mthreads         gcc (AIX)
+dnl  -pthread          gcc (Linux, FreeBSD, NetBSD, OpenBSD)
+dnl  -pthreads         gcc (Solaris) 
+dnl  -qthreaded        AIX cc V5
+dnl  -threads          gcc (HP-UX)
+dnl
+AC_DEFUN(PTHREADS_CHECK,[
+
+save_CFLAGS="$CFLAGS"
+save_LIBS="$LIBS"
+PTHREADS_ASSIGN_VARS
+PTHREADS_CHECK_COMPILE
+LIBS="$save_LIBS"
+CFLAGS="$save_CFLAGS"
+
+AC_CACHE_CHECK(for pthreads_cflags,ac_cv_pthreads_cflags,[
+ac_cv_pthreads_cflags=""
+if test "$pthreads_working" != "yes"; then
+  for flag in -kthread -pthread -pthreads -mthreads -Kthread -threads -mt -qthreaded; do 
+    ac_save="$CFLAGS"
+    CFLAGS="$CFLAGS $flag"
+    PTHREADS_CHECK_COMPILE
+    CFLAGS="$ac_save"
+    if test "$pthreads_working" = "yes"; then
+      ac_cv_pthreads_cflags="$flag"
+      break
+    fi
+  done
+fi
+])
+
+AC_CACHE_CHECK(for pthreads_lib, ac_cv_pthreads_lib,[
+ac_cv_pthreads_lib=""
+if test "$pthreads_working" != "yes"; then
+  for lib in pthread pthreads c_r; do
+    ac_save="$LIBS"
+    LIBS="$LIBS -l$lib"
+    PTHREADS_CHECK_COMPILE
+    LIBS="$ac_save"
+    if test "$pthreads_working" = "yes"; then
+      ac_cv_pthreads_lib="$lib"
+      break
+    fi
+  done
+fi
+])
+
+if test "$pthreads_working" = "yes"; then
+  threads_result="POSIX Threads found"
+else
+  threads_result="POSIX Threads not found"
+fi
+])dnl
+dnl
+dnl
+AC_DEFUN(PTHREADS_ASSIGN_VARS,[
+if test -n "$ac_cv_pthreads_lib"; then
+  LIBS="$LIBS -l$ac_cv_pthreads_lib"
+fi
+
+if test -n "$ac_cv_pthreads_cflags"; then
+  CFLAGS="$CFLAGS $ac_cv_pthreads_cflags"
+fi
+])dnl

TSRM/tsrm.m4

@@ -0,0 +1,98 @@
+
+dnl TSRM_CHECK_GCC_ARG(ARG, ACTION-IF-FOUND, ACTION-IF-NOT_FOUND)	
+AC_DEFUN(TSRM_CHECK_GCC_ARG,[
+  gcc_arg_name=[ac_cv_gcc_arg]translit($1,A-Z-,a-z_)
+  AC_CACHE_CHECK([whether $CC supports $1], [ac_cv_gcc_arg]translit($1,A-Z-,a-z_), [
+  echo 'void somefunc() { };' > conftest.c
+  cmd='$CC $1 -c conftest.c'
+  if eval $cmd 2>&1 | egrep -e $1 >/dev/null ; then
+    ac_result=no
+  else
+    ac_result=yes
+  fi
+  eval $gcc_arg_name=$ac_result
+  rm -f conftest.*
+  ])
+  if eval test "\$$gcc_arg_name" = "yes"; then
+    $2
+  else
+    :
+    $3
+  fi
+])
+
+AC_DEFUN(TSRM_BASIC_CHECKS,[
+
+AC_REQUIRE([AC_PROG_CC])dnl
+dnl AC_REQUIRE([AM_PROG_CC_STDC])dnl
+AC_REQUIRE([AC_PROG_CC_C_O])dnl
+AC_REQUIRE([AC_PROG_RANLIB])dnl
+
+AC_CHECK_HEADERS(stdarg.h)
+
+])
+
+
+AC_DEFUN(TSRM_CHECK_PTH,[
+
+AC_MSG_CHECKING(for GNU Pth)
+PTH_PREFIX="`$1 --prefix`"
+if test -z "$PTH_PREFIX"; then
+  AC_MSG_RESULT(Please check your Pth installation)
+fi
+
+CPPFLAGS="$CPPFLAGS `$1 --cflags`"
+LDFLAGS="$LDFLAGS `$1 --ldflags`"
+LIBS="$LIBS `$1 --libs`"
+
+AC_DEFINE(GNUPTH, 1, [Whether you use GNU Pth])
+AC_MSG_RESULT(yes - installed in $PTH_PREFIX)
+
+])
+
+sinclude(threads.m4)
+sinclude(TSRM/threads.m4)
+
+AC_DEFUN(TSRM_CHECK_PTHREADS,[
+		
+PTHREADS_CHECK
+		
+if test "$pthreads_working" != "yes"; then
+  AC_MSG_ERROR(Your system seems to lack POSIX threads.)
+fi
+		
+AC_DEFINE(PTHREADS, 1, Whether to use Pthreads)
+
+AC_MSG_CHECKING(for POSIX threads)
+AC_MSG_RESULT(yes)
+])
+
+
+AC_DEFUN(TSRM_THREADS_CHECKS,[
+
+dnl For the thread implementations, we always use --with-*
+dnl to maintain consistency
+
+AC_ARG_WITH(tsrm-pth,
+[  --with-tsrm-pth[=pth-config]    Use GNU Pth.],[
+  TSRM_PTH=$withval
+],[
+  TSRM_PTH=no
+])
+
+AC_ARG_WITH(tsrm-pthreads,
+[  --with-tsrm-pthreads    Use POSIX threads (default)],[
+  TSRM_PTHREADS=$withval
+],[
+  TSRM_PTHREADS=yes
+])
+
+test "$TSRM_PTH" = "yes" && TSRM_PTH=pth-config
+
+if test "$TSRM_PTH" != "no"; then
+  TSRM_CHECK_PTH($TSRM_PTH)
+elif test "$TSRM_PTHREADS" != "no"; then
+  TSRM_CHECK_PTHREADS
+fi
+
+])

TSRM/tsrm_config.w32.h

@@ -0,0 +1,15 @@
+#ifndef TSRM_CONFIG_W32_H
+#define TSRM_CONFIG_W32_H
+
+#define HAVE_UTIME 1
+#define HAVE_ALLOCA 1
+
+#undef inline
+#ifdef ZEND_WIN32_FORCE_INLINE
+# define inline __forceinline
+#else
+# define inline
+#endif
+
+
+#endif

TSRM/tsrm_config_common.h

@@ -0,0 +1,47 @@
+#ifndef TSRM_CONFIG_COMMON_H
+#define TSRM_CONFIG_COMMON_H
+
+#if WINNT|WIN32
+# define TSRM_WIN32
+#endif
+
+#ifndef TSRM_WIN32
+# include "tsrm_config.h"
+# include <sys/param.h>
+#else
+# include "tsrm_config.w32.h"
+#endif
+
+#ifdef TSRM_WIN32
+#include <malloc.h>
+#endif
+
+#if HAVE_ALLOCA_H
+#include <alloca.h>
+#endif
+
+#if HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#if HAVE_LIMITS_H
+#include <limits.h>
+#endif
+
+#ifndef MAXPATHLEN
+# ifdef PATH_MAX
+#  define MAXPATHLEN PATH_MAX
+# else
+#  define MAXPATHLEN 256
+# endif
+#endif
+
+#if (HAVE_ALLOCA || (defined (__GNUC__) && __GNUC__ >= 2))
+# define tsrm_do_alloca(p) alloca(p)
+# define tsrm_free_alloca(p)
+#else
+# define tsrm_do_alloca(p)   malloc(p)
+# define tsrm_free_alloca(p) free(p)
+#endif
+
+#endif /* TSRM_CONFIG_COMMON_H */

TSRM/tsrm_strtok_r.c

@@ -0,0 +1,63 @@
+#include <stdio.h>
+
+#include "tsrm_config_common.h"
+#include "tsrm_strtok_r.h"
+
+static inline int in_character_class(char ch, const char *delim)
+{
+	while (*delim) {
+		if (*delim == ch) {
+			return 1;
+		}
+		delim++;
+	}
+	return 0;
+}
+
+char *tsrm_strtok_r(char *s, const char *delim, char **last)
+{
+	char *token;
+
+	if (s == NULL) {
+		s = *last;
+	}
+
+	while (*s && in_character_class(*s, delim)) {
+		s++;
+	}
+	if (!*s) {
+		return NULL;
+	}
+
+	token = s;
+
+	while (*s && !in_character_class(*s, delim)) {
+		s++;
+	}
+	if (!*s) {
+		*last = s;
+	} else {
+		*s = '\0';
+		*last = s + 1;
+	}
+	return token;
+}
+
+#if 0
+
+main()
+{
+	char foo[] = "/foo/bar//\\barbara";
+	char *last;
+	char *token;
+
+	token = tsrm_strtok_r(foo, "/\\", &last);
+	while (token) {
+		printf ("Token = '%s'\n", token);
+		token = tsrm_strtok_r(NULL, "/\\", &last);
+	}
+	
+	return 0;
+}
+
+#endif

TSRM/tsrm_strtok_r.h

@@ -0,0 +1,6 @@
+#ifndef TSRM_STRTOK_R
+#define TSRM_STRTOK_R
+
+char *tsrm_strtok_r(char *s, const char *delim, char **last);
+
+#endif

TSRM/tsrm_virtual_cwd.c

@@ -0,0 +1,759 @@
+/*
+   +----------------------------------------------------------------------+
+   | 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: Andi Gutmans <andi@zend.com>                                |
+   |          Sascha Schumann <sascha@schumann.cx>                        |
+   +----------------------------------------------------------------------+
+*/
+
+/* $Id$ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <string.h>
+#include <stdio.h>
+#include <limits.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <fcntl.h>
+
+#include "tsrm_virtual_cwd.h"
+#include "tsrm_strtok_r.h"
+
+#ifdef TSRM_WIN32
+#include <io.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)
+MUTEX_T cwd_mutex;
+#endif
+
+#ifdef ZTS
+static ts_rsrc_id cwd_globals_id;
+#else
+static virtual_cwd_globals cwd_globals;
+#endif
+
+cwd_state main_cwd_state; /* True global */
+
+#ifndef TSRM_WIN32
+#include <unistd.h>
+#else
+#include <direct.h>
+#endif
+
+#ifndef S_ISDIR
+#define S_ISDIR(mode) ((mode) & _S_IFDIR)
+#endif
+
+#ifndef S_ISREG
+#define S_ISREG(mode) ((mode) & _S_IFREG)
+#endif
+
+#ifdef TSRM_WIN32
+#define tsrm_strtok_r(a,b,c) strtok((a),(b))
+#define TOKENIZER_STRING "/\\"
+	
+static int php_check_dots(const char *element, int n) 
+{
+	while (n-- > 0) if (element[n] != '.') break;
+
+	return (n != -1);
+}
+	
+#define IS_DIRECTORY_UP(element, len) \
+	(len >= 2 && !php_check_dots(element, len))
+
+#define IS_DIRECTORY_CURRENT(element, len) \
+	(len == 1 && ptr[0] == '.')
+
+
+#else
+#define TOKENIZER_STRING "/"
+#endif
+
+
+/* default macros */
+
+#ifndef IS_DIRECTORY_UP
+#define IS_DIRECTORY_UP(element, len) \
+	(len == 2 && memcmp(element, "..", 2) == 0)
+#endif
+
+#ifndef IS_DIRECTORY_CURRENT
+#define IS_DIRECTORY_CURRENT(element, len) \
+	(len == 1 && ptr[0] == '.')
+#endif
+
+/* define this to check semantics */
+#define IS_DIR_OK(s) (1)
+	
+#ifndef IS_DIR_OK
+#define IS_DIR_OK(state) (php_is_dir_ok(state) == 0)
+#endif
+
+
+#define CWD_STATE_COPY(d, s)				\
+	(d)->cwd_length = (s)->cwd_length;		\
+	(d)->cwd = (char *) malloc((s)->cwd_length+1);	\
+	memcpy((d)->cwd, (s)->cwd, (s)->cwd_length+1);
+
+#define CWD_STATE_FREE(s)			\
+	free((s)->cwd);
+	
+static int php_is_dir_ok(const cwd_state *state) 
+{
+	struct stat buf;
+
+	if (stat(state->cwd, &buf) == 0 && S_ISDIR(buf.st_mode))
+		return (0);
+
+	return (1);
+}
+
+static int php_is_file_ok(const cwd_state *state) 
+{
+	struct stat buf;
+
+	if (stat(state->cwd, &buf) == 0 && S_ISREG(buf.st_mode))
+		return (0);
+
+	return (1);
+}
+
+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)
+{
+	CWD_STATE_FREE(&cwd_globals->cwd);
+}
+
+static char *tsrm_strndup(const char *s, size_t length)
+{
+    char *p;
+
+    p = (char *) malloc(length+1);
+    if (!p) {
+        return (char *)NULL;
+    }
+    if (length) {
+        memcpy(p,s,length);
+    }
+    p[length]=0;
+    return p;
+}
+
+CWD_API void virtual_cwd_startup(void)
+{
+	char cwd[MAXPATHLEN];
+	char *result;
+
+	result = getcwd(cwd, sizeof(cwd));	
+	if (!result) {
+		cwd[0] = '\0';
+	}
+	main_cwd_state.cwd = strdup(cwd);
+	main_cwd_state.cwd_length = strlen(cwd);
+
+#ifdef ZTS
+	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);
+#endif
+
+#if defined(TSRM_WIN32) && defined(ZTS)
+	cwd_mutex = tsrm_mutex_alloc();
+#endif
+}
+
+CWD_API void virtual_cwd_shutdown(void)
+{
+#ifndef ZTS
+	cwd_globals_dtor(&cwd_globals);
+#endif
+#if defined(TSRM_WIN32) && defined(ZTS)
+	tsrm_mutex_free(cwd_mutex);
+#endif
+
+	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(int *length)
+{
+	cwd_state *state;
+	CWDLS_FETCH();
+
+	state = &CWDG(cwd);
+
+	if (state->cwd_length == 0) {
+		char *retval;
+
+		*length = 1;
+		retval = (char *) malloc(2);
+		retval[0] = DEFAULT_SLASH;
+		retval[1] = '\0';	
+		return retval;
+	}
+
+#ifdef TSRM_WIN32
+	/* If we have something like C: */
+	if (state->cwd_length == 2 && state->cwd[state->cwd_length-1] == ':') {
+		char *retval;
+
+		*length = state->cwd_length+1;
+		retval = (char *) malloc(*length+1);
+		memcpy(retval, state->cwd, *length);
+		retval[*length-1] = DEFAULT_SLASH;
+		retval[*length] = '\0';
+		return retval;
+	}
+#endif
+	*length = state->cwd_length;
+	return strdup(state->cwd);
+}
+
+
+/* Same semantics as UNIX getcwd() */
+CWD_API char *virtual_getcwd(char *buf, size_t size)
+{
+	size_t length;
+	char *cwd;
+
+	cwd = virtual_getcwd_ex(&length);
+
+	if (buf == NULL) {
+		return cwd;
+	}
+	if (length > size-1) {
+		free(cwd);
+		errno = ERANGE; /* Is this OK? */
+		return NULL;
+	}
+	memcpy(buf, cwd, length+1);
+	free(cwd);
+	return buf;
+}
+
+/* Resolve path relatively to state and put the real path into state */
+/* returns 0 for ok, 1 for error */
+CWD_API int virtual_file_ex(cwd_state *state, const char *path, verify_path_func verify_path)
+{
+	int path_length = strlen(path);
+	char *ptr, *path_copy;
+	char *tok = NULL;
+	int ptr_length;
+	cwd_state *old_state;
+	int ret = 0;
+	int copy_amount = -1;
+	char *free_path;
+	unsigned char is_absolute = 0;
+#ifndef TSRM_WIN32
+	char resolved_path[MAXPATHLEN];
+#endif
+
+	if (path_length == 0) 
+		return (0);
+
+#ifndef TSRM_WIN32
+	if (IS_ABSOLUTE_PATH(path, path_length)) {
+		if (realpath(path, resolved_path)) {
+			path = resolved_path;
+			path_length = strlen(path);
+		}
+	} else { /* Concat current directory with relative path and then run realpath() on it */
+		char *tmp;
+		char *ptr;
+
+		ptr = tmp = (char *) malloc(state->cwd_length+path_length+sizeof("/"));
+		if (!tmp) {
+			return 1;
+		}
+		memcpy(ptr, state->cwd, state->cwd_length);
+		ptr += state->cwd_length;
+		*ptr++ = DEFAULT_SLASH;
+		memcpy(ptr, path, path_length);
+		ptr += path_length;
+		*ptr = '\0';
+		if (realpath(tmp, resolved_path)) {
+			path = resolved_path;
+			path_length = strlen(path);
+		}
+		free(tmp);
+	}
+#endif
+	free_path = path_copy = tsrm_strndup(path, path_length);
+
+	old_state = (cwd_state *) malloc(sizeof(cwd_state));
+	CWD_STATE_COPY(old_state, state);
+#if VIRTUAL_CWD_DEBUG
+	fprintf(stderr,"cwd = %s path = %s\n", state->cwd, path);
+#endif
+	if (IS_ABSOLUTE_PATH(path_copy, path_length)) {
+		copy_amount = COPY_WHEN_ABSOLUTE;
+		is_absolute = 1;
+#ifdef TSRM_WIN32
+	} else if(IS_SLASH(path_copy[0])) {
+		copy_amount = 2;
+#endif
+	}
+
+	if (copy_amount != -1) {
+		state->cwd = (char *) realloc(state->cwd, copy_amount + 1);
+		if (copy_amount) {
+			if (is_absolute) {
+				memcpy(state->cwd, path_copy, copy_amount);
+				path_copy += copy_amount;
+			} else {
+				memcpy(state->cwd, old_state->cwd, copy_amount);
+			}
+		}
+		state->cwd[copy_amount] = '\0';
+		state->cwd_length = copy_amount;
+	}
+
+
+	ptr = tsrm_strtok_r(path_copy, TOKENIZER_STRING, &tok);
+	while (ptr) {
+		ptr_length = strlen(ptr);
+
+		if (IS_DIRECTORY_UP(ptr, ptr_length)) {
+			char save;
+
+			save = DEFAULT_SLASH;
+
+#define PREVIOUS state->cwd[state->cwd_length - 1]
+
+			while (IS_ABSOLUTE_PATH(state->cwd, state->cwd_length) &&
+					!IS_SLASH(PREVIOUS)) {
+				save = PREVIOUS;
+				PREVIOUS = '\0';
+				state->cwd_length--;
+			}
+
+			if (!IS_ABSOLUTE_PATH(state->cwd, state->cwd_length)) {
+				state->cwd[state->cwd_length++] = save;
+				state->cwd[state->cwd_length] = '\0';
+			} else {
+				PREVIOUS = '\0';
+				state->cwd_length--;
+			}
+		} else if (!IS_DIRECTORY_CURRENT(ptr, ptr_length)) {
+			state->cwd = (char *) realloc(state->cwd, state->cwd_length+ptr_length+1+1);
+			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);
+	}
+
+	if (state->cwd_length == COPY_WHEN_ABSOLUTE) {
+		state->cwd = (char *) realloc(state->cwd, state->cwd_length+1+1);
+		state->cwd[state->cwd_length] = DEFAULT_SLASH;
+		state->cwd[state->cwd_length+1] = '\0';
+		state->cwd_length++;
+	}
+
+	if (verify_path && verify_path(state)) {
+		CWD_STATE_FREE(state);
+
+		*state = *old_state;
+
+		ret = 1;
+	} else {
+		CWD_STATE_FREE(old_state);
+		ret = 0;
+	}
+	
+	free(old_state);
+	
+	free(free_path);
+#if VIRTUAL_CWD_DEBUG
+	fprintf (stderr, "virtual_file_ex() = %s\n",state->cwd);
+#endif
+	return (ret);
+}
+
+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))
+{
+	int length = strlen(path);
+	char *temp;
+	int retval;
+
+	if (length == 0) {
+		return 1; /* Can't cd to empty string */
+	}	
+	while(--length >= 0 && !IS_SLASH(path[length])) {
+	}
+
+	if (length == -1) {
+		/* No directory only file name */
+		errno = ENOENT;
+		return -1;
+	}
+
+	if (length == COPY_WHEN_ABSOLUTE && IS_ABSOLUTE_PATH(path, length+1)) { /* Also use trailing slash if this is absolute */
+		length++;
+	}
+	temp = (char *) tsrm_do_alloca(length+1);
+	memcpy(temp, path, length);
+	temp[length] = 0;
+#if VIRTUAL_CWD_DEBUG
+	fprintf (stderr, "Changing directory to %s\n", temp);
+#endif
+	retval = p_chdir(temp);
+	tsrm_free_alloca(temp);
+	return retval;
+}
+
+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);
+	
+	if(retval) {
+		int len = new_state.cwd_length>MAXPATHLEN-1?MAXPATHLEN-1:new_state.cwd_length;
+		memcpy(real_path, new_state.cwd, len);
+		real_path[len] = '\0';
+		return real_path;
+	}
+
+	return NULL;
+}
+
+CWD_API int virtual_filepath(const char *path, char **filepath)
+{
+	cwd_state new_state;
+	int retval;
+	CWDLS_FETCH();
+
+	CWD_STATE_COPY(&new_state, &CWDG(cwd));
+	retval = virtual_file_ex(&new_state, path, php_is_file_ok);
+
+	*filepath = new_state.cwd;
+
+	return retval;
+}
+
+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;
+	}
+
+	CWD_STATE_COPY(&new_state, &CWDG(cwd));
+	virtual_file_ex(&new_state, path, NULL);
+
+	f = fopen(new_state.cwd, mode);
+
+	CWD_STATE_FREE(&new_state);
+	return f;
+}
+
+#if HAVE_UTIME
+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);
+
+	ret = utime(new_state.cwd, buf);
+
+	CWD_STATE_FREE(&new_state);
+	return ret;
+}
+#endif
+
+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);
+
+	ret = chmod(new_state.cwd, mode);
+
+	CWD_STATE_FREE(&new_state);
+	return ret;
+}
+
+#ifndef TSRM_WIN32
+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);
+
+	ret = chown(new_state.cwd, owner, group);
+
+	CWD_STATE_FREE(&new_state);
+	return ret;
+}
+#endif
+
+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);
+
+	if (flags & O_CREAT) {
+		mode_t mode;
+		va_list arg;
+
+		va_start(arg, flags);
+		mode = va_arg(arg, mode_t);
+		va_end(arg);
+
+		f = open(new_state.cwd, flags, mode);
+	} else {
+		f = open(new_state.cwd, flags);
+	}	
+	CWD_STATE_FREE(&new_state);
+	return f;
+}
+
+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);
+
+	f = creat(new_state.cwd,  mode);
+
+	CWD_STATE_FREE(&new_state);
+	return f;
+}
+
+
+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);
+
+	retval = stat(new_state.cwd, buf);
+
+	CWD_STATE_FREE(&new_state);
+	return retval;
+}
+
+#ifndef TSRM_WIN32
+
+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);
+
+	retval = lstat(new_state.cwd, buf);
+
+	CWD_STATE_FREE(&new_state);
+	return retval;
+}
+
+#endif
+
+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);
+
+	retval = unlink(new_state.cwd);
+
+	CWD_STATE_FREE(&new_state);
+	return retval;
+}
+
+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);
+
+#ifdef TSRM_WIN32
+	retval = mkdir(new_state.cwd);
+#else
+	retval = mkdir(new_state.cwd, mode);
+#endif
+	CWD_STATE_FREE(&new_state);
+	return retval;
+}
+
+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);
+
+	retval = rmdir(new_state.cwd);
+
+	CWD_STATE_FREE(&new_state);
+	return retval;
+}
+
+#ifdef TSRM_WIN32
+DIR *opendir(const char *name);
+#endif
+
+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);
+
+	retval = opendir(new_state.cwd);
+
+	CWD_STATE_FREE(&new_state);
+	return retval;
+}
+
+#ifndef TSRM_WIN32
+
+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);
+
+	ptr = command_line = (char *) malloc(command_length + sizeof("cd  ; ") + CWDG(cwd).cwd_length+1);
+	if (!command_line) {
+		return NULL;
+	}
+	memcpy(ptr, "cd ", sizeof("cd ")-1);
+	ptr += sizeof("cd ")-1;
+
+	if (CWDG(cwd).cwd_length == 0) {
+		*ptr++ = DEFAULT_SLASH;
+	} else {
+		memcpy(ptr, CWDG(cwd).cwd, CWDG(cwd).cwd_length);
+		ptr += CWDG(cwd).cwd_length;
+	}
+	
+	*ptr++ = ' ';
+	*ptr++ = ';';
+	*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;
+}
+
+#else
+
+/* 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)
+{
+	char prev_cwd[MAXPATHLEN];
+	char *getcwd_result;
+	FILE *retval;
+	CWDLS_FETCH();
+
+	getcwd_result = getcwd(prev_cwd, MAXPATHLEN);
+	if (!getcwd_result) {
+		return NULL;
+	}
+
+#ifdef ZTS
+	tsrm_mutex_lock(cwd_mutex);
+#endif
+
+	chdir(CWDG(cwd).cwd);
+	retval = _popen(command, type);
+	chdir(prev_cwd);
+
+#ifdef ZTS
+	tsrm_mutex_unlock(cwd_mutex);
+#endif
+
+	return retval;
+}
+
+#endif
+
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */

TSRM/tsrm_virtual_cwd.h

@@ -0,0 +1,208 @@
+/*
+   +----------------------------------------------------------------------+
+   | 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: Andi Gutmans <andi@zend.com>                                |
+   |          Sascha Schumann <sascha@schumann.cx>                        |
+   +----------------------------------------------------------------------+
+*/
+
+/* $Id$ */
+
+#ifndef VIRTUAL_CWD_H
+#define VIRTUAL_CWD_H
+
+#include "tsrm_config_common.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <ctype.h>
+
+#ifdef HAVE_UTIME_H
+#include <utime.h>
+#endif
+
+#ifdef HAVE_STDARG_H
+#include <stdarg.h>
+#endif
+
+#ifndef TSRM_WIN32
+#include <unistd.h>
+#endif
+
+#ifdef TSRM_WIN32
+#include "readdir.h"
+#include <sys/utime.h>
+/* mode_t isn't defined on Windows */
+typedef int mode_t;
+
+#define DEFAULT_SLASH '\\'
+#define IS_SLASH(c)	((c) == '/' || (c) == '\\')
+#define COPY_WHEN_ABSOLUTE 2
+#define IS_ABSOLUTE_PATH(path, len) \
+	(len >= 2 && isalpha(path[0]) && path[1] == ':')
+
+#else
+#ifdef HAVE_DIRENT_H
+#include <dirent.h>
+#endif
+
+#define DEFAULT_SLASH '/'
+#define IS_SLASH(c)	((c) == '/')
+
+#endif
+
+
+#ifndef COPY_WHEN_ABSOLUTE
+#define COPY_WHEN_ABSOLUTE 0
+#endif
+
+#ifndef IS_ABSOLUTE_PATH	
+#define IS_ABSOLUTE_PATH(path, len) \
+	(IS_SLASH(path[0]))
+#endif
+
+#ifdef TSRM_EXPORTS
+#define CWD_EXPORTS
+#endif
+
+#ifdef TSRM_WIN32
+#       ifdef CWD_EXPORTS
+#       define CWD_API __declspec(dllexport)
+#       else
+#       define CWD_API __declspec(dllimport)
+#       endif
+#else
+#define CWD_API
+#endif
+
+typedef struct _cwd_state {
+	char *cwd;
+	int cwd_length;
+} cwd_state;
+
+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(int *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 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_stat(const char *path, struct stat *buf);
+#ifndef TSRM_WIN32
+CWD_API int virtual_lstat(const char *path, struct stat *buf);
+#endif
+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);
+#endif
+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);
+#endif
+
+CWD_API int virtual_file_ex(cwd_state *state, const char *path, verify_path_func verify_path);
+
+typedef struct _virtual_cwd_globals {
+	cwd_state cwd;
+} virtual_cwd_globals;
+
+#ifdef ZTS
+# 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
+ * If the program defines VIRTUAL_DIR it will use the
+ * virtual_* functions 
+ */
+
+#ifdef VIRTUAL_DIR
+
+#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_STAT(path, buff) virtual_stat(path, buff)
+#ifdef TSRM_WIN32
+#define V_LSTAT(path, buff) virtual_stat(path, buff)
+#else
+#define V_LSTAT(path, buff) virtual_lstat(path, buff)
+#endif
+#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 V_UTIME(path,time) virtual_utime(path,time)
+#endif
+#define V_CHMOD(path,mode) virtual_chmod(path,mode)
+#ifndef TSRM_WIN32
+#define V_CHOWN(path,owner,group) virtual_chown(path,owner,group)
+#endif
+
+#else
+
+#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_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 V_UTIME(path,time) utime(path,time)
+#endif
+#define V_CHMOD(path,mode) chmod(path,mode)
+#ifndef TSRM_WIN32
+#define V_CHOWN(path,owner,group) chown(path,owner,group)
+#endif
+
+#endif
+
+#endif /* VIRTUAL_CWD_H */

Zend/LICENSE

@@ -1,56 +1,116 @@
--------------------------------------------------------------------- 
-                The Zend Engine License, Version 2.00
-Copyright (c) 1999-2003 Zend Technologies Ltd. All rights reserved.
--------------------------------------------------------------------- 
+---------------------------------------------------------------------------
+                    The Zend License, version 0.92
+           Copyright (C) 1999-2000    Zend Technologies Ltd.
+---------------------------------------------------------------------------
 
-Redistribution and use in source and binary forms, with or without
-modification, is permitted provided that the following conditions
-are met:
+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.
 
-  1. Redistributions of source code must retain the above copyright
-     notice, this list of conditions and the following disclaimer. 
- 
-  2. Redistributions in binary form must reproduce the above 
-     copyright notice, this list of conditions and the following 
-     disclaimer in the documentation and/or other materials provided
-     with the distribution.
- 
-  3. The names "Zend" and "Zend Engine" must not be used to endorse
-     or promote products derived from this software without prior
-     permission from Zend Technologies Ltd. For written permission,
-     please contact license@zend.com. 
- 
-  4. Zend Technologies Ltd. may publish revised and/or new versions
-     of the license from time to time. Each version will be given a
-     distinguishing version number.
-     Once covered code has been published under a particular version
-     of the license, you may always continue to use it under the
-     terms of that version. You may also choose to use such covered
-     code under the terms of any subsequent version of the license
-     published by Zend Technologies Ltd. No one other than Zend
-     Technologies Ltd. has the right to modify the terms applicable
-     to covered code created under this License.
+For more information about Zend please visit http://www.zend.com/
+For license related questions please mail license@zend.com
 
-  5. Redistributions of any form whatsoever must retain the following
-     acknowledgment:
-     "This product includes the Zend Engine, freely available at
-     http://www.zend.com"
+===========================================================================
 
-  6. All advertising materials mentioning features or use of this
-     software must display the following acknowledgment:
-     "The Zend Engine is freely available at http://www.zend.com"
+			     THE Q PUBLIC LICENSE
+				  version 1.0
 
-THIS SOFTWARE IS PROVIDED BY ZEND TECHNOLOGIES LTD. ``AS IS'' AND 
-ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 
-PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ZEND
-TECHNOLOGIES LTD.  BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
-USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
-OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGE.
+		   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

@@ -1,53 +1,41 @@
 ## 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
+#CLEANFILES = zend-parser.c zend-parser.h zend-scanner.c zend-parser.output 
 
 AUTOMAKE_OPTIONS=foreign
-noinst_LTLIBRARIES=libZend.la
+EXTRA_LTLIBRARIES=libZend_cc.la libZend_c.la
+noinst_LTLIBRARIES=$(ZEND_SCANNER) libZend.la
+
+libZend_cc_la_SOURCES=zend-scanner-cc.cc
+libZend_c_la_SOURCES=zend-scanner.c
 
 libZend_la_SOURCES=\
-	zend_language_parser.y zend_language_scanner.l \
-	zend_ini_parser.y zend_ini_scanner.l \
+	zend-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 zend_qsort.c zend_objects.c zend_object_handlers.c \
-	zend_objects_API.c zend_ts_hash.c zend_stream.c zend_mm.c \
-	zend_default_classes.c zend_reflection_api.c \
-	zend_iterators.c zend_interfaces.c zend_exceptions.c
+	zend_list.c zend_indent.c zend_builtin_functions.c zend_sprintf.c
 
-libZend_la_LDFLAGS =
-libZend_la_LIBADD = @ZEND_EXTRA_LIBS@
+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_parser.h
+$(libZend_la_OBJECTS) zend-scanner.lo zend-scanner-cc.lo: zend-parser.h
 
-zend_ini_scanner.lo: zend_ini_parser.h
+zend-scanner.c: $(srcdir)/zend-scanner.l
+	$(LEX) -Pzend -o$@ -i $(srcdir)/zend-scanner.l
 
-# Language parser/scanner rules
+zend-scanner-cc.cc: $(srcdir)/zend-scanner.l
+	$(LEX) -+ -B -i -S$(srcdir)/flex.skl -Pzend -o$@ $(srcdir)/zend-scanner.l
 
-zend_language_scanner.c: $(srcdir)/zend_language_scanner.l
-	$(LEX) -Pzend -S$(srcdir)/flex.skl -o$@ -i $(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_ -S$(srcdir)/flex.skl -o$@ -i $(srcdir)/zend_ini_scanner.l
-
-zend_ini_parser.h: zend_ini_parser.c
+zend-parser.h: zend-parser.c
+zend-parser.c: $(srcdir)/zend-parser.y
+	$(YACC) -p zend -v -d $(srcdir)/zend-parser.y -o zend-parser.c
 
 depend:
 
 zend_execute.lo: $(srcdir)/zend_execute.c
-	$(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(CPPFLAGS) $(INLINE_CFLAGS) -c $(srcdir)/zend_execute.c
-
+	$(LIBTOOL) --mode=compile $(CC) $(DEFS) $(INCLUDES) $(CPPFLAGS) $(INLINE_CFLAGS) -c $(srcdir)/zend_execute.c

Zend/OBJECTS2_HOWTO

@@ -1,195 +0,0 @@
-Creating an object
-------------------
-
-Object can be created in the following ways:
-
-1. As a result of a function call. E.g.:
-
-$foo = create_new_foo("parameter");
-$foo->run();
-
-The function should create a new zval, create new object and get the
-handle for it, set handle and handler table as needed. Note that the
-handle is the only ID of the object, so it should be enough to
-identify it.
-
-2. Overriding create_object handler for class. E.g.:
-
-$foo = new Java("some.Class.here", "parameter");
-$foo->run();
-
-The  create_object handler function should create a new zval, create
-new object and get the handle for it, set handle and handler table as
-needed, and also provide constructor method that would handle
-constructor call. The get_constructor handler table entry should be
-used for that. Do not rely class entry's constructor, unless you refer
-to it from get_constructor handler.
-
-Object maintenance
-------------------
-
-The handlers add_ref and del_ref are called when a new zval referring
-to the object is created. This does not create a new object - both
-zvals still refer to the same object.
-
-clone_obj handler should create a new object, identical to an old one, 
-but being a separate entity.
-
-delete_obj should destroy an object, all references to it become
-invalid.
-
-Object access - read
---------------------
-
-read_property is used to read object's property. This value is not
-meant to be changed. The handler returns zval * with the value.
-
-Object access - write
----------------------
-
-write_property is used to directly write object's property by
-name.  This handler is used to assign property variables or to change them 
-in operations like += or ++ (unless get_property_zval_ptr is also set).
-
-get_property_zval_ptr is used to obtain pointer to modifiable zval for 
-operations like += or ++. This should be used only if your object model 
-stores properties as real zval's that can be modified from outside. 
-Otherwise this handler should be NULL and the engine will use 
-read_property and write_property instead.
-
-get_property_ptr is used to obtain zval ** for future writing to
-it. If your object properties are stored as zval*, return real place
-where the property is stored. If the aren't, the best way is to create 
-proxy object and handle it via get and set methods (see below). 
-This method is meant to be used for send-by-reference and assign-by-reference
-use of object properties. If you don;t want to implement property
-referencing for your objects, you can set this handler to NULL. 
-
-get and set handlers are used when engine needs to access the object
-as a value. E.g., in the following situation:
-
-$foo =& $obj->bar;
-$foo = 1;
-
-if $foo is an object (e.g., proxy object from get_property_ptr) it
-would be accessed using write handler.
-
-Object access - method call
----------------------------
-
-get_method handler is used to find method description by name. It
-should set right type, function name and parameter mask for the
-method. If the type is ZEND_OVERLOADED_FUNCTION, the method would be
-called via call_method handler, otherwise it would be called with
-standard Zend means.
-
-get_constructor performs the same function as get_method, but for the
-object constructor. 
-
-call_method handler is used to perform method call. Parameters are
-passed like to any other Zend internal function. 
-
-Object - comparison
--------------------
-
-Objects can be compared via compare_objects handler. This is used with 
-== operation, === compares objects by handles, i.e., return true if
-and only if it's really the same object. Note that objects from
-different object types (i.e., having different handlers) can not be
-compared. 
-
-Objects - reflection
---------------------
-
-get_class_name is used to retrieve class name of the object. 
-get_class_entry returns class entry (zend_class_entry) for the object,
-in case there exists PHP class for it.
-No other reflection functions are currently implemented.
-
-Objects - data structures and handlers
----------------------------------------
-
-The object is represented by the following structure:
-
-struct _zend_object_value {
-	zend_object_handle handle;
-	zend_object_handlers *handlers;
-};
-
-handle is an ID of the object among the objects of the same type (not
-class!). The type of the object and how it behaves is determined by
-the handler table.
-
-typedef struct _zend_object_handlers {
-	zend_object_add_ref_t                    add_ref;
-	zend_object_del_ref_t                    del_ref;
-	zend_object_delete_obj_t                 delete_obj;
-	zend_object_clone_obj_t                  clone_obj;	
-	zend_object_read_property_t              read_property;
-	zend_object_write_property_t             write_property;
-	zend_object_get_property_ptr_t           get_property_ptr;
-	zend_object_get_property_zval_ptr_t      get_property_zval_ptr;
-	zend_object_get_t                        get;
-	zend_object_set_t                        set;
-	zend_object_has_property_t               has_property;
-	zend_object_unset_property_t             unset_property;
-	zend_object_get_properties_t             get_properties;
-	zend_object_get_method_t                 get_method;
-	zend_object_call_method_t                call_method;
-	zend_object_get_constructor_t            get_constructor;
-	zend_object_get_class_entry_t            get_class_entry;
-	zend_object_get_class_name_t             get_class_name;
-	zend_object_compare_t                    compare_objects;
-} zend_object_handlers;
-
-See zend_object_handlers.h for prototypes. All objects are passed as zval's.
-
-Handlers explained:
-
-add_ref - called when a copy of the object handle is created.
-
-del_ref - called when a copy of the object handle is destroyed.
-
-delete_obj - called when an object needs to be destroyed.
-
-clone_obj - called when a new object identical to an old one should be 
-created (unlike Zend Engine 1, this never happens unless explicitly
-asked for).
-
-read_property - returns zval *, containing the value of the
-property. Is used when value of the property should be retrieved for
-reading.
-
-write_property - assigns value to certain property of the object. 
-
-get_property_zval_ptr - retrieves zval** for being directly modified by 
-the engine. If your properties are not zval's, don't define it.
-
-get_property_ptr - retrieves zval** for the property of the value, to
-be used for read and write. If object properties are not zval's
-natively, this method should create and return proxy object for use
-with get and set methods.
-
-get - retrieves zval* for object contents. To be used mainly with
-proxy objects from get_property_ptr, but also may be used for
-convert_to_* functions.
-
-set - sets value for object contents. To be used mainly with
-proxy objects from get_property_ptr.
-
-has_property - checks if the object has certain property set.
-
-unset_property - removes value for the property of the object
-
-get_method - retrieves description of the method
-
-call_method - calls the method (parameters should be put on stack like 
-for any other PHP internal function).
-
-get_constructor - get description for the object constructor method
-
-get_class_entry - should return the class entry for the object
-
-get_class_name - get the name of the class the object belongs to
-
-compare_objects - compares if two objects are equal

Zend/RFCs/001.txt

@@ -1,136 +0,0 @@
-Revamped object model using object handles
-===========================================
-
-Background
-----------
-
-In the Zend Engine 1.0 (and its predecessor the PHP 3 scripting
-engine) the object model's design is that instantiated objects are
-language values. This means that when programmers are performing
-operations, such variable assignment and passing parameters to
-functions, objects are handled very similarly to the way other
-primitive types are handled such as integers and strings.
-Semantically this means that the whole object is being copied. The
-approach Java takes is different where one refers to objects by handle
-and not by value (one can think of a handle as an objects' ID).
-
-Need
-----
-
-Unfortunately, the approach taken up to now has severely limited the
-Zend Engine's object oriented model, both feature and simplicity
-wise. One of the main problems with the former approach is that object
-instantiation and duplication is very hard to control, a problem which
-can not only lead to inefficient development but also often to strange
-run-time behavior. Changing the object model to a handle oriented
-model will allow the addressing of many needs such as destructors,
-de-referencing method return values, tight control of object
-duplication and more.
-
-Overview
---------
-
-The proposed object model is very much influenced by the Java
-model. In general, when you create a new object you will be getting a
-handle to the object instead of the object itself. When this handle is
-sent to functions, assigned and copied it is only the handle which is
-copied/sent/assigned. The object itself is never copied nor
-duplicated. This results in all handles of this object to always point
-at the same object making it a very consistent solution and saving
-unnecessary duplication and confusing behavior.
-
-Functionality
--------------
-
-After this change the basic use of objects will be almost identical to
-previous versions of the scripting engine.  However, you won't bump
-into awkward and confusing copying & destructing of objects.  In order
-to create and use a new object instance you will do the following:
-$object = new MyClass(); $object->method();
-
-The previous code will assign $object the handle of a new instance of
-the class MyClass and call one of its methods.
-
- 
-Consider the following code:
-
-1	class MyClass
-2	{
-3		function setMember($value)
-4		{
-5			$this->member = $value;
-6		}
-7	
-8		function getMember()
-9		{
-10			return $this->member;
-11		}
-12	}
-13	
-14	function foo($obj)
-15	{
-16		$obj->setMember("foo");
-17	}
-18	
-19	$object = new MyClass();
-20	$object->setMember("bar");
-21	foo($object);
-22	print $object->getMember();
-
-Without the new Java-like handles, at line 20 the objects' data member
-member is set to the string value of "bar".  Because of the internal
-representation of objects in the Zend Engine 1.0, the object is marked
-as a reference, and when it is sent by value to the function foo, it
-is duplicated (!).  Therefore, the call to foo() on line 21 will
-result in the $obj->setMember("foo") call being called on a duplicate
-of $object. Line 22 will then result in "bar" being printed.
-
-This is how the scripting engine has worked until today. Most
-developers are probably unaware of the fact that they aren't always
-talking to the same object but often duplicates; others may have
-realized this can usually be solved by always passing objects by
-reference (unless a replica is actually desired, which is uncommon).
-
-The new object model will allow for a much more intuitive
-implementation of the code.  On line 21, the object's handle (ID) is
-passed to foo() by value. Inside foo(), the object is fetched
-according to this handle and, therefore, the setMember() method is
-called on the originally instantiated object and not a copy.  Line 22
-will therefore result in "foo" being printed.  This approach gives
-developers tighter control of when objects are created and duplicated.
-An additional not-as-important benefit is that the object handle will
-be passed to foo() by value, which most probably will also save
-unnecessary duplication of the value containing the ID itself and thus
-additionally improving run-time performance.
-
-This was just a simple description of why the new object model solves
-awkward behavior and makes object handling much easier, intuitive and
-efficient.  The importance of this change goes far beyond what is
-mentioned in this section as you will see in further sections which
-describe new features with a majority of them being based on this
-change.
-
-Compatibility Notes
---------------------
-
-Many PHP programmers aren't even aware of the copying quirks of the
-current object model and, therefore, there is a relatively good chance
-that the amount of PHP applications that will work out of the box or
-after a very small amount of modifications would be high.
-
-To simplify migration, version 2.0 will support an optional
-'auto-clone' feature, which will perform a cloning of the object
-whenever it would have been copied in version 1.0.  Optionally, it
-will also be possible to request that the engine will emit an E_NOTICE
-message whenever such an automatic clone occurs, in order to allow
-developers to gradually migrate to the version 2.0-style behavior
-(without automatic clones).
-
-Dependencies
-------------
-
-The new object model is not dependent on other features.  Many of the
-other Zend Engine 2.0 features, such as the $foo->bar()->barbara()
-syntax, destructors and others completely rely on this new object
-model.
-

Zend/RFCs/002.txt

@@ -1,169 +0,0 @@
-Title:           Zend 2.0 Namespaces
-Version:         $Revision$
-Status:          declined
-Maintainer:      Stig S. Bakken <ssb@php.net>
-Created:         2001-09-08
-Modified:        2001-09-08
-                  
-
-1. Background/Need
-==================
-
-PHP and Zend 1.0 have come to a point where a lot of reusable code is
-being written; from simple functions and classes to entire application
-frameworks.  It is becoming increasingly difficult to avoid symbol
-name collisions with the current scoping methods.
-
-The symbol scopes available in Zend 1.0 are the global scope, the
-class scope and the function scope.  All scopes but classes may
-contain variables, only the class and global scopes may contain
-functions, while only the global scope may contain constants and
-classes.  This means that all of Zend 1.0's scoping methods are
-inherently limited for solving symbol name collision problems.
-
-
-2. Overview
-===========
-
-Namespaces in Zend 2.0 provide a way to manage the symbol collision
-problem by making it possible to define multiple symbol tables able to
-contain all types of symbols.  Zend will get the notion of a current
-namespace, defaulting to the current global one.  The current name
-space may be changed on a file-by-file basis.  Symbols in other name
-spaces than the current one may be referenced using a new namespace
-operator.  It will be possible to "import" symbols from one namespace
-into another.
-
-
-3. Functionality
-================
-
-3.1. Namespace Syntax
-=====================
-
-The namespace operator ":" is used to refer to symbols in other
-namespaces than the current one:
-
-Class:          Namespace:class
-Function:       Namespace:function
-Static method:  Namespace:class::method
-Variable:       $Namespace:variable
-Constant:       Namespace:CONSTANT
-Class variable: $Namespace:class::variable
-
-To refer to symbols in the global namespace, symbols are prefixed with
-only the namespace operator:
-
-Class:          :class
-Function:       :function
-Static method:  :class::method
-Variable:       $:variable
-Constant:       :CONSTANT
-Class variable: $:class::variable
-
-Note: $:variable will effectively be just another syntax for
-$GLOBALS['variable'].
-
-A namespace may have a name containing a ":", it is always the last
-":" character in the symbol qualifier that is the actual namespace
-operator:
-
-Class:          Name:Space:class
-Function:       Name:Space:function
-Static method:  Name:Space:class::method
-Variable:       $Name:Space:variable
-Constant:       Name:Space:CONSTANT
-Class variable: $Name:Space:class::variable
-
-(Here, the ":" between "Name" and "Space" is part of the name, it is
-the one after "Space" that is the namespace operator.)
-
-
-3.2. Defining Namespaces
-========================
-
-Individual files may define a namespace that will apply to the entire
-file.  If no "namespace" operator occurs in the file, it will be in
-the global namespace:
-
- 1 namespace HTML;
- 2 
- 3 class Form {
- 4     function Form() {
- 5         // constructor
- 6     }
- 7     // ...
- 8 }
-
-Or with the "nested" name syntax:
-
- 1 namespace HTML:Form;
- 2 
- 3 class Image {
- 4     var $src;
- 5     function Image($src) {
- 6         $this->src = $src;
- 7     }
- 8     // ...
- 9 }
-
-Code executed within the "HTML" namespace may refer to the Form class
-as just "Form".  Code executed from within other namespaces has to
-refer to it as "HTML:Form".  The "namespace" statement must occur
-before any other statements in the file.
-
-# [ssb 2001-09-08]:
-# Should it be possible to "add" symbols to a namespace by including a
-# second file with the same namespace statement?
-
-
-3.3. Importing Symbols
-======================
-
-It is possible to import symbols from another namespace into the
-current one with the "import" statement:
-
-  import * from HTML;          // all symbols
-
-  import Form from HTML;       // single symbols
-
-  import Form,Table from HTML; // multiple symbols
-
-There is a potential for name clashes between symols of different
-types that have the same qualifier syntax.  These are resolved in this
-order: class, function, constant.
-
-Optionally, the symbol type may be explicitly given to import (as
-"class", "function", "variable" or "constant"):
-
-  import class Form from HTML;
-
-And finally, you may import all symbols of a given type:
-
-  import constant * from HTML:Table;
-
-The namespace with its symbols must already be defined before using
-"import".
-
-
-4. Compatibility Notes
-======================
-
-Old code that does not take advantage of namespaces will run without
-modifications.
-
-
-5. Dependencies
-===============
-
-The class variable syntax depends on this class variables being
-implemented in the new ZE2 object model.
-
-
-6. Acknowledgements
-===================
-
-Andi Gutmans <andi@zend.com> and Zeev Suraski <zeev@zend.com> for
-initial ZE2 namespaces proposal
-
-Dean Hall <php@apt7.com> for the initial symbol qualification syntax

Zend/RFCs/003.txt

@@ -1,72 +0,0 @@
-Title:           Loose type requirements for functions
-Version:         $Revision$
-Status:          draft
-Maintainer:      Brian Moon <brianm@dealnews.com>
-Created:         2001-09-17
-Modified:        2001-09-17
-
-
-1. Background/Need
-==================
-
-Many internal function of PHP will reject parameters because of their
-type (the array and variable function come to mind).  For userland
-this is not an easy task as there is no uniform way to do it.  An
-addition to the engine for requiring loose types would allow
-delevopers to know that the data passed to their functions is of the
-correct type and reduce the need for duplicating the same code in
-every function to check for the type of data.
-
-
-2. Overview
-===========
-
-Loose typing mostly means evaluating the contents of the variable and
-not the type of the variable itself.  The requirements for this would
-and should work much like several of the is_* functions do now.
-
-The typing of parameters would be optional and those not typed would
-simply continue to be treated as they are now.
-
-3. Functionality
-================
-
-3.1. Allowed Types
-==================
-
-Only loose types should be needed to ensure the data is usable by the
-function.  Duplicating the functionallity of is_scalar, is_resource,
-is_array and is_object should give developers all the information they
-need to use a variable correctly.
-
-3.2. Syntax
-===========
-
-The current function syntax should be expanded to allow typing of
-variables inline in a C style.
-
-function foo ($var){
-}
-
-could be changed to require an array such as:
-
-function foo (array $var){
-}
-
-3.3. Errors
-===========
-
-Mis-matches in type should be reported as fatal errors and should halt
-the execution of a script as that function can not be run and code
-following could not reliably run.
-
-
-4. Compatibility Notes
-======================
-
-Old code that does not take advantage of this will run without
-modifications.
-
-
-
-

Zend/Zend.dsp

@@ -7,20 +7,20 @@
 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 
 !MESSAGE NMAKE /f "Zend.mak".
-!MESSAGE
+!MESSAGE 
 !MESSAGE You can specify a configuration when running NMAKE
 !MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE
+!MESSAGE 
 !MESSAGE NMAKE /f "Zend.mak" CFG="Zend - Win32 Release_inline"
-!MESSAGE
+!MESSAGE 
 !MESSAGE Possible choices for configuration are:
-!MESSAGE
+!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
+!MESSAGE 
 
 # Begin Project
 # PROP AllowPerConfigDependencies 0
@@ -95,7 +95,7 @@ LIB32=link.exe -lib
 # ADD BASE LIB32 /nologo
 # ADD LIB32 /nologo
 
-!ENDIF
+!ENDIF 
 
 # Begin Target
 
@@ -107,6 +107,14 @@ LIB32=link.exe -lib
 # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
 # Begin Source File
 
+SOURCE=".\zend-parser.c"
+# End Source File
+# Begin Source File
+
+SOURCE=".\zend-scanner.c"
+# End Source File
+# Begin Source File
+
 SOURCE=.\zend.c
 # End Source File
 # Begin Source File
@@ -131,18 +139,6 @@ SOURCE=.\zend_constants.c
 # End Source File
 # Begin Source File
 
-SOURCE=.\zend_default_classes.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_interfaces.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
@@ -155,6 +151,10 @@ SOURCE=.\zend_extensions.c
 # End Source File
 # Begin Source File
 
+SOURCE=.\zend_gcc_inline.c
+# End Source File
+# Begin Source File
+
 SOURCE=.\zend_hash.c
 # End Source File
 # Begin Source File
@@ -167,26 +167,6 @@ 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
@@ -195,22 +175,6 @@ SOURCE=.\zend_llist.c
 # End Source File
 # Begin Source File
 
-SOURCE=.\zend_mm.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_object_handlers.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_objects.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_objects_API.c
-# End Source File
-# Begin Source File
-
 SOURCE=.\zend_opcode.c
 # End Source File
 # Begin Source File
@@ -223,14 +187,6 @@ SOURCE=.\zend_ptr_stack.c
 # End Source File
 # Begin Source File
 
-SOURCE=.\zend_qsort.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_reflection_api.c
-# End Source File
-# Begin Source File
-
 SOURCE=.\zend_sprintf.c
 # End Source File
 # Begin Source File
@@ -239,14 +195,6 @@ SOURCE=.\zend_stack.c
 # End Source File
 # Begin Source File
 
-SOURCE=.\zend_stream.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_ts_hash.c
-# End Source File
-# Begin Source File
-
 SOURCE=.\zend_variables.c
 # End Source File
 # End Group
@@ -259,6 +207,18 @@ SOURCE=.\FlexLexer.h
 # End Source File
 # Begin Source File
 
+SOURCE=.\modules.h
+# End Source File
+# Begin Source File
+
+SOURCE=".\zend-parser.h"
+# End Source File
+# Begin Source File
+
+SOURCE=".\zend-scanner.h"
+# End Source File
+# Begin Source File
+
 SOURCE=.\zend.h
 # End Source File
 # Begin Source File
@@ -287,18 +247,6 @@ SOURCE=.\zend_constants.h
 # End Source File
 # Begin Source File
 
-SOURCE=.\zend_default_classes.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_interfaces.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
@@ -307,10 +255,6 @@ 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
@@ -323,10 +267,6 @@ 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
@@ -339,30 +279,6 @@ 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_istdiostream.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
@@ -371,26 +287,6 @@ SOURCE=.\zend_llist.h
 # End Source File
 # Begin Source File
 
-SOURCE=.\zend_mm.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_modules.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_object_handlers.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_objects.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_objects_API.h
-# End Source File
-# Begin Source File
-
 SOURCE=.\zend_operators.h
 # End Source File
 # Begin Source File
@@ -399,26 +295,10 @@ SOURCE=.\zend_ptr_stack.h
 # End Source File
 # Begin Source File
 
-SOURCE=.\zend_qsort.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_reflection_api.h
-# End Source File
-# Begin Source File
-
 SOURCE=.\zend_stack.h
 # End Source File
 # Begin Source File
 
-SOURCE=.\zend_stream.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_ts_hash.h
-# End Source File
-# Begin Source File
-
 SOURCE=.\zend_variables.h
 # End Source File
 # End Group
@@ -427,48 +307,23 @@ SOURCE=.\zend_variables.h
 # 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= \
-	bison --output=zend_ini_parser.c -v -d -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"
+SOURCE=".\zend-parser.y"
 
 !IF  "$(CFG)" == "Zend - Win32 Release"
 
 # Begin Custom Build
 InputDir=.
-InputPath=".\zend_language_parser.y"
+InputPath=".\zend-parser.y"
 
 BuildCmds= \
-	bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y
+	if not "X%CYGWIN%"=="X" bison --output=zend-parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p zend zend-parser.y \
+	if "X%CYGWIN%"=="X" bison --output=zend-parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p zend zend-parser.y \
+	
 
-"$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+"$(InputDir)\zend-parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
    $(BuildCmds)
 
-"$(InputDir)\zend_language_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+"$(InputDir)\zend-parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
    $(BuildCmds)
 # End Custom Build
 
@@ -476,15 +331,17 @@ BuildCmds= \
 
 # Begin Custom Build
 InputDir=.
-InputPath=".\zend_language_parser.y"
+InputPath=".\zend-parser.y"
 
 BuildCmds= \
-	bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y
+	if not "X%CYGWIN%"=="X" bison --output=zend-parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p zend zend-parser.y \
+	if "X%CYGWIN%"=="X" bison --output=zend-parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p zend zend-parser.y \
+	
 
-"$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+"$(InputDir)\zend-parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
    $(BuildCmds)
 
-"$(InputDir)\zend_language_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+"$(InputDir)\zend-parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
    $(BuildCmds)
 # End Custom Build
 
@@ -492,19 +349,21 @@ BuildCmds= \
 
 # Begin Custom Build
 InputDir=.
-InputPath=".\zend_language_parser.y"
+InputPath=".\zend-parser.y"
 
 BuildCmds= \
-	bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y
+	if not "X%CYGWIN%"=="X" bison --output=zend-parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p zend zend-parser.y \
+	if "X%CYGWIN%"=="X" bison --output=zend-parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p zend zend-parser.y \
+	
 
-"$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+"$(InputDir)\zend-parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
    $(BuildCmds)
 
-"$(InputDir)\zend_language_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+"$(InputDir)\zend-parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
    $(BuildCmds)
 # End Custom Build
 
-!ENDIF
+!ENDIF 
 
 # End Source File
 # End Group
@@ -513,64 +372,39 @@ BuildCmds= \
 # PROP Default_Filter "l"
 # Begin Source File
 
-SOURCE=.\flex.skl
-# End Source File
-# 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"
+SOURCE=".\zend-scanner.l"
 
 !IF  "$(CFG)" == "Zend - Win32 Release"
 
 # Begin Custom Build
-InputPath=".\zend_language_scanner.l"
+InputPath=".\zend-scanner.l"
 
-"zend_language_scanner.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-	flex -i -Pzend -ozend_language_scanner.c zend_language_scanner.l
+"zend-scanner.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	flex -i -Pzend -ozend-scanner.c zend-scanner.l
 
 # End Custom Build
 
 !ELSEIF  "$(CFG)" == "Zend - Win32 Debug"
 
 # Begin Custom Build
-InputPath=".\zend_language_scanner.l"
+InputPath=".\zend-scanner.l"
 
-"zend_language_scanner.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-	flex -i -Pzend -ozend_language_scanner.c zend_language_scanner.l
+"zend-scanner.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	flex -i -Pzend -ozend-scanner.c zend-scanner.l
 
 # End Custom Build
 
 !ELSEIF  "$(CFG)" == "Zend - Win32 Release_inline"
 
 # Begin Custom Build
-InputPath=".\zend_language_scanner.l"
+InputPath=".\zend-scanner.l"
 
-"zend_language_scanner.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-	flex -i -Pzend -ozend_language_scanner.c zend_language_scanner.l
+"zend-scanner.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	flex -i -Pzend -ozend-scanner.c zend-scanner.l
 
 # End Custom Build
 
-!ENDIF
+!ENDIF 
 
 # End Source File
 # End Group

Zend/Zend.m4

@@ -1,8 +1,3 @@
-dnl
-dnl $Id$
-dnl
-dnl This file contains Zend specific autoconf functions.
-dnl
 
 AC_DEFUN(LIBZEND_BISON_CHECK,[
 
@@ -10,9 +5,9 @@ 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| grep 'GNU Bison' | cut -d ' ' -f 4 | sed -e 's/\./ /' | tr -d 'a-z'`
-    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}).)
+    set `bison --version| sed -e 's/^GNU Bison version //' -e 's/\./ /'`
+    if test "${1}" = "1" -a "${2}" -lt "25"; then
+        AC_MSG_WARN(You will need bison 1.25 if you want to regenerate the Zend parser (found ${1}.${2}).)
     fi
     AC_MSG_RESULT(${1}.${2} (ok))
 fi
@@ -24,7 +19,7 @@ AC_DEFUN(LIBZEND_BASIC_CHECKS,[
 AC_REQUIRE([AC_PROG_YACC])
 AC_REQUIRE([AC_PROG_CC])
 AC_REQUIRE([AC_PROG_CC_C_O])
-AC_REQUIRE([AC_PROG_LEX])
+AC_REQUIRE([AM_PROG_LEX])
 AC_REQUIRE([AC_HEADER_STDC])
 
 LIBZEND_BISON_CHECK
@@ -48,57 +43,44 @@ string.h \
 unistd.h \
 stdarg.h \
 sys/types.h \
-sys/time.h \
 signal.h \
 unix.h \
-stdlib.h \
-mach-o/dyld.h \
 dlfcn.h)
 
 AC_TYPE_SIZE_T
 AC_TYPE_SIGNAL
 
-AC_DEFUN(LIBZEND_LIBDL_CHECKS,[
 AC_CHECK_LIB(dl, dlopen, [LIBS="-ldl $LIBS"])
 AC_CHECK_FUNC(dlopen,[AC_DEFINE(HAVE_LIBDL, 1,[ ])])
-])
-
-AC_DEFUN(LIBZEND_DLSYM_CHECK,[
-dnl
-dnl Ugly hack to check if dlsym() requires a leading underscore in symbol name.
-dnl
-AC_MSG_CHECKING([whether dlsym() requires a leading underscore in symbol names])
-_LT_AC_TRY_DLOPEN_SELF([
-  AC_MSG_RESULT(no)
-], [
-  AC_MSG_RESULT(yes)
-  AC_DEFINE(DLSYM_NEEDS_UNDERSCORE, 1, [Define if dlsym() requires a leading underscore in symbol names. ])
-], [
-  AC_MSG_RESULT(no)
-], [])
-])
 
 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 fpclass)
+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],[
+[  --enable-debug         Compile with debugging symbols],[
   ZEND_DEBUG=$enableval
 ],[
   ZEND_DEBUG=no
@@ -106,21 +88,32 @@ AC_ARG_ENABLE(debug,
 
 ])
 
+
+
+
+
+
+
+
+
+
+
+
 AC_DEFUN(LIBZEND_OTHER_CHECKS,[
 
-AC_ARG_ENABLE(maintainer-zts,
-[  --enable-maintainer-zts Enable thread safety - for code maintainers only],[
-  ZEND_MAINTAINER_ZTS=$enableval
+AC_ARG_ENABLE(experimental-zts,
+[  --enable-experimental-zts   This will most likely break your build],[
+  ZEND_EXPERIMENTAL_ZTS=$enableval
 ],[
-  ZEND_MAINTAINER_ZTS=no
+  ZEND_EXPERIMENTAL_ZTS=no
 ])  
 
 AC_ARG_ENABLE(inline-optimization,
-[  --disable-inline-optimization 
-                          If building zend_execute.lo fails, try this switch.],[
+[  --enable-inline-optimization   If you have much memory and are using
+                                 gcc, you might try this.],[
   ZEND_INLINE_OPTIMIZATION=$enableval
 ],[
-  ZEND_INLINE_OPTIMIZATION=yes
+  ZEND_INLINE_OPTIMIZATION=no
 ])
 
 AC_ARG_ENABLE(memory-limit,
@@ -130,15 +123,8 @@ AC_ARG_ENABLE(memory-limit,
   ZEND_MEMORY_LIMIT=no
 ])
 
-AC_ARG_ENABLE(zend-multibyte,
-[  --enable-zend-multibyte Compile with zend multibyte support. ], [
-  ZEND_MULTIBYTE=$enableval
-],[
-  ZEND_MULTIBYTE=no
-])
-
-AC_MSG_CHECKING(whether to enable thread-safety)
-AC_MSG_RESULT($ZEND_MAINTAINER_ZTS)
+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)
@@ -148,9 +134,6 @@ AC_MSG_RESULT($ZEND_MEMORY_LIMIT)
 
 AC_MSG_CHECKING(whether to enable Zend debugging)
 AC_MSG_RESULT($ZEND_DEBUG)
-
-AC_MSG_CHECKING(whether to enable Zend multibyte)
-AC_MSG_RESULT($ZEND_MULTIBYTE)
 	
 if test "$ZEND_DEBUG" = "yes"; then
   AC_DEFINE(ZEND_DEBUG,1,[ ])
@@ -167,25 +150,26 @@ fi
 
 test -n "$DEBUG_CFLAGS" && CFLAGS="$CFLAGS $DEBUG_CFLAGS"
 
-if test "$ZEND_MAINTAINER_ZTS" = "yes"; then
+if test "$ZEND_EXPERIMENTAL_ZTS" = "yes"; then
   AC_DEFINE(ZTS,1,[ ])
-  CFLAGS="$CFLAGS -DZTS"
+  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
 
-if test "$ZEND_MULTIBYTE" = "yes"; then
-  AC_DEFINE(ZEND_MULTIBYTE, 1, [ ])
-fi
-
 changequote({,})
 if test -n "$GCC" && test "$ZEND_INLINE_OPTIMIZATION" != "yes"; then
-  INLINE_CFLAGS=`echo $ac_n "$CFLAGS $ac_c" | sed s/-O[0-9s]*//`
+  INLINE_CFLAGS=`echo $ac_n "$CFLAGS $ac_c" | sed s/-O[0-9]*//`
 else
   INLINE_CFLAGS="$CFLAGS"
 fi
@@ -195,56 +179,44 @@ AC_C_INLINE
 
 AC_SUBST(INLINE_CFLAGS)
 
-
-dnl test and set the alignment define for ZEND_MM
-dnl this also does the logarithmic test for ZEND_MM.
-AC_MSG_CHECKING(for MM alignment and log values)
-
-AC_TRY_RUN([
-#include <stdio.h>
-
-typedef union _mm_align_test {
-  void *ptr;
-  double dbl;
-  long lng;
-} mm_align_test;
-
-#if (defined (__GNUC__) && __GNUC__ >= 2)
-#define ZEND_MM_ALIGNMENT (__alignof__ (mm_align_test))
-#else
-#define ZEND_MM_ALIGNMENT (sizeof(mm_align_test))
-#endif
-
-int main()
-{
-  int i = ZEND_MM_ALIGNMENT;
-  int zeros = 0;
-  FILE *fp;
-
-  while (i & ~0x1) {
-    zeros++;
-    i = i >> 1;
-  }
-
-  fp = fopen("conftest.zend", "w");
-  fprintf(fp, "%d %d\n", ZEND_MM_ALIGNMENT, zeros);  
-  fclose(fp);
-
-  exit(0);
-}
-], [
-  LIBZEND_MM_ALIGN=`cat conftest.zend | cut -d ' ' -f 1`
-  LIBZEND_MM_ALIGN_LOG2=`cat conftest.zend | cut -d ' ' -f 2`
-  AC_DEFINE_UNQUOTED(ZEND_MM_ALIGNMENT, $LIBZEND_MM_ALIGN, [ ])
-  AC_DEFINE_UNQUOTED(ZEND_MM_ALIGNMENT_LOG2, $LIBZEND_MM_ALIGN_LOG2, [ ]) 
-])
-
-AC_MSG_RESULT(done)
-
 ])
 
 
 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

@@ -30,7 +30,7 @@
 	".\zend_config.w32.h"\
 	".\zend_execute.h"\
 	".\zend_llist.h"\
-	".\zend_modules.h"\
+	".\modules.h"\
 	".\zend_operators.h"\
 	".\zend_ptr_stack.h"\
 	".\zend_stack.h"\
@@ -63,7 +63,7 @@
 	".\zend_constants.h"\
 	".\zend_execute.h"\
 	".\zend_llist.h"\
-	".\zend_modules.h"\
+	".\modules.h"\
 	".\zend_operators.h"\
 	".\zend_ptr_stack.h"\
 	".\zend_stack.h"\
@@ -86,7 +86,7 @@
 	".\zend_llist.h"\
 	".\zend_ptr_stack.h"\
 	".\zend_stack.h"\
-	".\zend_language_parser.tab.h"\
+	".\zend-parser.tab.h"\
 	".\zend.h"\
 	".\zend_errors.h"\
 	".\zend_globals.h"\
@@ -110,7 +110,7 @@
 	".\zend_config.w32.h"\
 	".\zend_execute.h"\
 	".\zend_llist.h"\
-	".\zend_modules.h"\
+	".\modules.h"\
 	".\zend_operators.h"\
 	".\zend_ptr_stack.h"\
 	".\zend_stack.h"\
@@ -168,7 +168,7 @@
 	".\zend_constants.h"\
 	".\zend_execute.h"\
 	".\zend_llist.h"\
-	".\zend_modules.h"\
+	".\modules.h"\
 	".\zend_ptr_stack.h"\
 	".\zend_stack.h"\
 	".\zend_variables.h"\
@@ -200,7 +200,7 @@
 	".\zend_constants.h"\
 	".\zend_execute.h"\
 	".\zend_llist.h"\
-	".\zend_modules.h"\
+	".\modules.h"\
 	".\zend_operators.h"\
 	".\zend_ptr_stack.h"\
 	".\zend_stack.h"\

Zend/ZendTS.dsp

@@ -4,7 +4,7 @@
 
 # TARGTYPE "Win32 (x86) Static Library" 0x0104
 
-CFG=ZendTS - Win32 Release_TSDbg
+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 
@@ -13,14 +13,13 @@ CFG=ZendTS - Win32 Release_TSDbg
 !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_TSDbg"
+!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 "ZendTS - Win32 Release_TSDbg" (based on "Win32 (x86) Static Library")
 !MESSAGE 
 
 # Begin Project
@@ -96,29 +95,6 @@ LIB32=link.exe -lib
 # ADD BASE LIB32 /nologo
 # ADD LIB32 /nologo
 
-!ELSEIF  "$(CFG)" == "ZendTS - Win32 Release_TSDbg"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Output_Dir "ZendTS___Win32_Release_TSDbg"
-# PROP BASE Intermediate_Dir "ZendTS___Win32_Release_TSDbg"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 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_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 BASE CPP /YX
-# ADD CPP /nologo /MD /W3 /GX /Zi /Od /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
-
 !ENDIF 
 
 # Begin Target
@@ -126,12 +102,19 @@ LIB32=link.exe -lib
 # Name "ZendTS - Win32 Release_TS"
 # Name "ZendTS - Win32 Debug_TS"
 # Name "ZendTS - Win32 Release_TS_inline"
-# Name "ZendTS - Win32 Release_TSDbg"
 # Begin Group "Source Files"
 
 # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
 # Begin Source File
 
+SOURCE=".\zend-parser.c"
+# End Source File
+# Begin Source File
+
+SOURCE=".\zend-scanner.cpp"
+# End Source File
+# Begin Source File
+
 SOURCE=.\zend.c
 # End Source File
 # Begin Source File
@@ -156,18 +139,10 @@ SOURCE=.\zend_constants.c
 # End Source File
 # Begin Source File
 
-SOURCE=.\zend_default_classes.c
-# End Source File
-# Begin Source File
-
 SOURCE=.\zend_dynamic_array.c
 # End Source File
 # Begin Source File
 
-SOURCE=.\zend_exceptions.c
-# End Source File
-# Begin Source File
-
 SOURCE=.\zend_execute.c
 # End Source File
 # Begin Source File
@@ -192,34 +167,6 @@ 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_interfaces.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_iterators.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
@@ -228,22 +175,6 @@ SOURCE=.\zend_llist.c
 # End Source File
 # Begin Source File
 
-SOURCE=.\zend_mm.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_object_handlers.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_objects.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_objects_API.c
-# End Source File
-# Begin Source File
-
 SOURCE=.\zend_opcode.c
 # End Source File
 # Begin Source File
@@ -256,14 +187,6 @@ SOURCE=.\zend_ptr_stack.c
 # End Source File
 # Begin Source File
 
-SOURCE=.\zend_qsort.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_reflection_api.c
-# End Source File
-# Begin Source File
-
 SOURCE=.\zend_sprintf.c
 # End Source File
 # Begin Source File
@@ -272,14 +195,6 @@ SOURCE=.\zend_stack.c
 # End Source File
 # Begin Source File
 
-SOURCE=.\zend_stream.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_ts_hash.c
-# End Source File
-# Begin Source File
-
 SOURCE=.\zend_variables.c
 # End Source File
 # End Group
@@ -292,6 +207,18 @@ SOURCE=.\FlexLexer.h
 # End Source File
 # Begin Source File
 
+SOURCE=.\modules.h
+# End Source File
+# Begin Source File
+
+SOURCE=".\zend-parser.h"
+# End Source File
+# Begin Source File
+
+SOURCE=".\zend-scanner.h"
+# End Source File
+# Begin Source File
+
 SOURCE=.\zend.h
 # End Source File
 # Begin Source File
@@ -320,10 +247,6 @@ SOURCE=.\zend_constants.h
 # End Source File
 # Begin Source File
 
-SOURCE=.\zend_default_classes.h
-# End Source File
-# Begin Source File
-
 SOURCE=.\zend_dynamic_array.h
 # End Source File
 # Begin Source File
@@ -332,11 +255,11 @@ SOURCE=.\zend_errors.h
 # End Source File
 # Begin Source File
 
-SOURCE=.\zend_exceptions.h
+SOURCE=.\zend_execute.h
 # End Source File
 # Begin Source File
 
-SOURCE=.\zend_execute.h
+SOURCE=.\zend_execute_locks.h
 # End Source File
 # Begin Source File
 
@@ -368,38 +291,6 @@ 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_interfaces.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_istdiostream.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_iterators.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
@@ -408,26 +299,6 @@ SOURCE=.\zend_llist.h
 # End Source File
 # Begin Source File
 
-SOURCE=.\zend_mm.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_modules.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_object_handlers.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_objects.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_objects_API.h
-# End Source File
-# Begin Source File
-
 SOURCE=.\zend_operators.h
 # End Source File
 # Begin Source File
@@ -436,26 +307,10 @@ SOURCE=.\zend_ptr_stack.h
 # End Source File
 # Begin Source File
 
-SOURCE=.\zend_qsort.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_reflection_api.h
-# End Source File
-# Begin Source File
-
 SOURCE=.\zend_stack.h
 # End Source File
 # Begin Source File
 
-SOURCE=.\zend_stream.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_ts_hash.h
-# End Source File
-# Begin Source File
-
 SOURCE=.\zend_variables.h
 # End Source File
 # End Group
@@ -464,21 +319,23 @@ SOURCE=.\zend_variables.h
 # PROP Default_Filter "y"
 # Begin Source File
 
-SOURCE=.\zend_ini_parser.y
+SOURCE=".\zend-parser.y"
 
 !IF  "$(CFG)" == "ZendTS - Win32 Release_TS"
 
 # Begin Custom Build
 InputDir=.
-InputPath=.\zend_ini_parser.y
+InputPath=".\zend-parser.y"
 
 BuildCmds= \
-	bison --output=zend_ini_parser.c -v -d -p ini_ zend_ini_parser.y
+	if not "X%CYGWIN%"=="X" bison --output=zend-parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p zend zend-parser.y \
+	if "X%CYGWIN%"=="X" bison --output=zend-parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p zend zend-parser.y \
+	
 
-"$(InputDir)\zend_ini_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+"$(InputDir)\zend-parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
    $(BuildCmds)
 
-"$(InputDir)\zend_ini_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+"$(InputDir)\zend-parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
    $(BuildCmds)
 # End Custom Build
 
@@ -486,15 +343,17 @@ BuildCmds= \
 
 # Begin Custom Build
 InputDir=.
-InputPath=.\zend_ini_parser.y
+InputPath=".\zend-parser.y"
 
 BuildCmds= \
-	bison --output=zend_ini_parser.c -v -d -p ini_ zend_ini_parser.y
+	if not "X%CYGWIN%"=="X" bison --output=zend-parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p zend zend-parser.y \
+	if "X%CYGWIN%"=="X" bison --output=zend-parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p zend zend-parser.y \
+	
 
-"$(InputDir)\zend_ini_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+"$(InputDir)\zend-parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
    $(BuildCmds)
 
-"$(InputDir)\zend_ini_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+"$(InputDir)\zend-parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
    $(BuildCmds)
 # End Custom Build
 
@@ -502,102 +361,17 @@ BuildCmds= \
 
 # Begin Custom Build
 InputDir=.
-InputPath=.\zend_ini_parser.y
+InputPath=".\zend-parser.y"
 
 BuildCmds= \
-	bison --output=zend_ini_parser.c -v -d -p ini_ zend_ini_parser.y
+	if not "X%CYGWIN%"=="X" bison --output=zend-parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p zend zend-parser.y \
+	if "X%CYGWIN%"=="X" bison --output=zend-parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p zend zend-parser.y \
+	
 
-"$(InputDir)\zend_ini_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+"$(InputDir)\zend-parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
    $(BuildCmds)
 
-"$(InputDir)\zend_ini_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-   $(BuildCmds)
-# End Custom Build
-
-!ELSEIF  "$(CFG)" == "ZendTS - Win32 Release_TSDbg"
-
-# Begin Custom Build
-InputDir=.
-InputPath=.\zend_ini_parser.y
-
-BuildCmds= \
-	bison --output=zend_ini_parser.c -v -d -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= \
-	bison --output=zend_language_parser.c -v -d -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= \
-	bison --output=zend_language_parser.c -v -d -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= \
-	bison --output=zend_language_parser.c -v -d -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_TSDbg"
-
-# Begin Custom Build
-InputDir=.
-InputPath=".\zend_language_parser.y"
-
-BuildCmds= \
-	bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y
-
-"$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-   $(BuildCmds)
-
-"$(InputDir)\zend_language_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+"$(InputDir)\zend-parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
    $(BuildCmds)
 # End Custom Build
 
@@ -610,96 +384,35 @@ BuildCmds= \
 # PROP Default_Filter "l"
 # Begin Source File
 
-SOURCE=.\flex.skl
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_ini_scanner.l
+SOURCE=".\zend-scanner.l"
 
 !IF  "$(CFG)" == "ZendTS - Win32 Release_TS"
 
 # Begin Custom Build
-InputPath=.\zend_ini_scanner.l
+InputPath=".\zend-scanner.l"
 
-"zend_ini_scanner.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-	flex -B -i -Sflex.skl -Pini_ -ozend_ini_scanner.c zend_ini_scanner.l
+"zend-scanner.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	flex -+ -B -i -Sflex.skl -Pzend -ozend-scanner.cpp zend-scanner.l
 
 # End Custom Build
 
 !ELSEIF  "$(CFG)" == "ZendTS - Win32 Debug_TS"
 
 # Begin Custom Build
-InputPath=.\zend_ini_scanner.l
+InputPath=".\zend-scanner.l"
 
-"zend_ini_scanner.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-	flex -B -i -Sflex.skl -Pini_ -ozend_ini_scanner.c zend_ini_scanner.l
+"zend-scanner.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	flex -+ -B -i -Sflex.skl -Pzend -ozend-scanner.cpp zend-scanner.l
 
 # End Custom Build
 
 !ELSEIF  "$(CFG)" == "ZendTS - Win32 Release_TS_inline"
 
 # Begin Custom Build
-InputPath=.\zend_ini_scanner.l
+InputPath=".\zend-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)" == "ZendTS - Win32 Release_TSDbg"
-
-# 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
-
-!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.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-	flex -B -i -Sflex.skl -Pzend -ozend_language_scanner.c zend_language_scanner.l
-
-# End Custom Build
-
-!ELSEIF  "$(CFG)" == "ZendTS - Win32 Debug_TS"
-
-# Begin Custom Build
-InputPath=".\zend_language_scanner.l"
-
-"zend_language_scanner.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-	flex -B -i -Sflex.skl -Pzend -ozend_language_scanner.c 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.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-	flex -B -i -Sflex.skl -Pzend -ozend_language_scanner.c zend_language_scanner.l
-
-# End Custom Build
-
-!ELSEIF  "$(CFG)" == "ZendTS - Win32 Release_TSDbg"
-
-# Begin Custom Build
-InputPath=".\zend_language_scanner.l"
-
-"zend_language_scanner.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-	flex -B -i -Sflex.skl -Pzend -ozend_language_scanner.c zend_language_scanner.l
+"zend-scanner.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	flex -+ -B -i -Sflex.skl -Pzend -ozend-scanner.cpp zend-scanner.l
 
 # End Custom Build
 

Zend/acconfig.h

@@ -1,31 +1,11 @@
-/*
-   +----------------------------------------------------------------------+
-   | Zend Engine                                                          |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2004 Zend Technologies Ltd. (http://www.zend.com) |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 2.00 of the Zend license,     |
-   | that is bundled with this package in the file LICENSE, and is        |
-   | available through the world-wide-web at the following url:           |
-   | http://www.zend.com/license/2_00.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>                                |
-   +----------------------------------------------------------------------+
-*/
-
-/* $Id$ */
-
 #define ZEND_API
 #define ZEND_DLEXPORT
-#define ZEND_DLIMPORT
 
-#ifndef NETWARE
 @TOP@
-#endif
+
+/* these are defined by automake */
+#undef PACKAGE
+#undef VERSION
 
 #undef uint
 #undef ulong
@@ -33,11 +13,7 @@
 /* Define if you want to enable memory limit support */
 #define MEMORY_LIMIT 0
 
-#ifndef NETWARE
 @BOTTOM@
-#endif
-
-#ifndef ZEND_ACCONFIG_H_NO_C_PROTOS
 
 #ifdef HAVE_STDLIB_H
 # include <stdlib.h>
@@ -47,10 +23,6 @@
 # include <sys/types.h>
 #endif
 
-#ifdef HAVE_IEEEFP_H
-# include <ieeefp.h>
-#endif
-
 #ifdef HAVE_STRING_H
 # include <string.h>
 #else
@@ -65,23 +37,19 @@ int zend_sprintf(char *buffer, const char *format, ...);
 
 #include <math.h>
 
-#ifndef zend_isnan
 #ifdef HAVE_ISNAN
 #define zend_isnan(a) isnan(a)
-#elif defined(HAVE_FPCLASS)
-#define zend_isnan(a) ((fpclass(a) == FP_SNAN) || (fpclass(a) == FP_QNAN))
+#elif defined(NAN)
+#define zend_isnan(a) (((a)==NAN)?1:0)
 #else
 #define zend_isnan(a) 0
 #endif
-#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)
-#elif defined(HAVE_FPCLASS)
-#define zend_isinf(a) ((fpclass(a) == FP_PINF) || (fpclass(a) == FP_NINF))
 #else
 #define zend_isinf(a) 0
 #endif
@@ -96,12 +64,9 @@ int zend_sprintf(char *buffer, const char *format, ...);
 #define zend_finite(a) (zend_isnan(a) ? 0 : zend_isinf(a) ? 0 : 1)
 #endif
 
-#endif /* ifndef ZEND_ACCONFIG_H_NO_C_PROTOS */
-
 /*
  * Local variables:
  * tab-width: 4
  * c-basic-offset: 4
- * indent-tabs-mode: t
  * End:
  */

Zend/configure.in

@@ -2,7 +2,7 @@ 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_INIT_AUTOMAKE(zend, 0.80A)
 AM_CONFIG_HEADER(zend_config.h)
 AM_SANITY_CHECK
 AM_MAINTAINER_MODE
@@ -17,8 +17,6 @@ test -z "$CFLAGS" && auto_cflags=1
 sinclude(Zend.m4)
 
 LIBZEND_BASIC_CHECKS
-LIBZEND_LIBDL_CHECKS
-LIBZEND_DLSYM_CHECK
 
 AM_PROG_LIBTOOL
 if test "$enable_debug" != "yes"; then
@@ -37,9 +35,9 @@ fi
 LIBZEND_ENABLE_DEBUG
 LIBZEND_OTHER_CHECKS
 
-ZEND_EXTRA_LIBS="$LIBS"
+EXTRA_LIBS="$LIBS"
 LIBS=""
-AC_SUBST(ZEND_EXTRA_LIBS)
+AC_SUBST(EXTRA_LIBS)
 AC_OUTPUT(Makefile)
 
 # Local Variables:

Zend/flex.skl

@@ -1,8 +1,7 @@
-/* A Lexical scanner generated by flex */
+/* A lexical scanner generated by flex */
 
 /* Scanner skeleton version:
  * $Header$
- * vim:ft=lex:
  */
 
 #define FLEX_SCANNER
@@ -63,8 +62,6 @@ class istream;
 #define yyconst
 #endif
 
-#undef YY_USE_PROTOS
-#define YY_USE_PROTOS
 
 #ifdef YY_USE_PROTOS
 #define YY_PROTO(proto) proto
@@ -99,7 +96,7 @@ class istream;
 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 
 /* Special action meaning "start processing a new file". */
-#define YY_NEW_FILE yyrestart( SCNG(yy_in) TSRMLS_CC )
+#define YY_NEW_FILE yyrestart( yyin )
 
 #define YY_END_OF_BUFFER_CHAR 0
 
@@ -110,9 +107,9 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE;
 
 extern int yyleng;
 %-
+extern FILE *yyin, *yyout;
 %*
 
-
 #define EOB_ACT_CONTINUE_SCAN 0
 #define EOB_ACT_END_OF_FILE 1
 #define EOB_ACT_LAST_MATCH 2
@@ -143,7 +140,7 @@ extern int yyleng;
 		} \
 	while ( 0 )
 
-#define unput(c) yyunput( c, yytext_ptr TSRMLS_CC )
+#define unput(c) yyunput( c, yytext_ptr )
 
 /* The following is because we cannot portably get our hands on size_t
  * (without autoconf's help, which isn't available because we want
@@ -155,7 +152,7 @@ typedef unsigned int yy_size_t;
 struct yy_buffer_state
 	{
 %-
-	struct _zend_file_handle *yy_input_file;
+	FILE *yy_input_file;
 %+
 	istream* yy_input_file;
 %*
@@ -214,8 +211,7 @@ struct yy_buffer_state
 	};
 
 %- Standard (non-C++) definition
-#define yy_current_buffer SCNG(current_buffer)
-#define yy_hold_char SCNG(_yy_hold_char)
+static YY_BUFFER_STATE yy_current_buffer = 0;
 %*
 
 /* We provide macros for accessing buffer states in case in the
@@ -227,50 +223,36 @@ struct yy_buffer_state
 
 %- Standard (non-C++) definition
 /* yy_hold_char holds the character lost when yytext is formed. */
-
-#if 0
 static char yy_hold_char;
 
 static int yy_n_chars;		/* number of characters read into yy_ch_buf */
-#endif
+
+
+int yyleng;
 
 /* Points to current character in buffer. */
-#define yy_c_buf_p SCNG(c_buf_p)
-#define yy_init SCNG(init)
-#define yy_start SCNG(start)
-
-#ifdef ZTS
-#define TSRMLS_D	void ***tsrm_ls
-#define TSRMLS_DC	, TSRMLS_D
-#define TSRMLS_C	tsrm_ls
-#define TSRMLS_CC	, TSRMLS_C
-#else
-#define TSRMLS_D
-#define TSRMLS_DC
-#define TSRMLS_C
-#define TSRMLS_CC
-#endif
+static char *yy_c_buf_p = (char *) 0;
+static int yy_init = 1;		/* whether we need to initialize */
+static int yy_start = 0;	/* 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 ...
  */
-/* static int yy_did_buffer_switch_on_eof; */
-#define yy_did_buffer_switch_on_eof SCNG(_yy_did_buffer_switch_on_eof)
+static int yy_did_buffer_switch_on_eof;
 
-void yyrestart YY_PROTO(( struct _zend_file_handle *input_file TSRMLS_DC ));
+void yyrestart YY_PROTO(( FILE *input_file ));
 
-void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer TSRMLS_DC ));
-void yy_load_buffer_state YY_PROTO(( TSRMLS_D ));
-YY_BUFFER_STATE yy_create_buffer YY_PROTO(( struct _zend_file_handle *file, int size TSRMLS_DC ));
-void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b TSRMLS_DC ));
-void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, struct _zend_file_handle *file TSRMLS_DC ));
-void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b TSRMLS_DC ));
-#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer TSRMLS_CC )
-
-YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size TSRMLS_DC ));
-YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str TSRMLS_DC ));
-YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len TSRMLS_DC ));
+void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
+void yy_load_buffer_state YY_PROTO(( void ));
+YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
+void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
+void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
+void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
+#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
 
+YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
+YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
+YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
 %*
 
 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
@@ -282,52 +264,28 @@ static void yy_flex_free YY_PROTO(( void * ));
 #define yy_set_interactive(is_interactive) \
 	{ \
 	if ( ! yy_current_buffer ) \
-		yy_current_buffer = yy_create_buffer( SCNG(yy_in), YY_BUF_SIZE TSRMLS_CC ); \
+		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
 	yy_current_buffer->yy_is_interactive = is_interactive; \
 	}
 
 #define yy_set_bol(at_bol) \
 	{ \
 	if ( ! yy_current_buffer ) \
-		yy_current_buffer = yy_create_buffer( SCNG(yy_in), YY_BUF_SIZE TSRMLS_CC ); \
+		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
 	yy_current_buffer->yy_at_bol = at_bol; \
 	}
 
 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
 
 %% yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here
-#undef yyleng
-#define yyleng SCNG(yy_leng)
-#undef yytext
-#define yytext SCNG(yy_text)
-#undef yytext_ptr
-#define yytext_ptr SCNG(yy_text)
-#undef yyin
-#define yyin SCNG(yy_in)
-#undef yyout
-#define yyout SCNG(yy_out)
-#undef yy_last_accepting_state
-#define yy_last_accepting_state SCNG(_yy_last_accepting_state)
-#undef yy_last_accepting_cpos
-#define yy_last_accepting_cpos SCNG(_yy_last_accepting_cpos)
-#undef yy_more_flag
-#define yy_more_flag SCNG(_yy_more_flag)
-#undef yy_more_len
-#define yy_more_len SCNG(_yy_more_len)
-
 
 %- Standard (non-C++) definition
-static yy_state_type yy_get_previous_state YY_PROTO(( TSRMLS_D ));
-static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state TSRMLS_DC ));
-static int yy_get_next_buffer YY_PROTO(( TSRMLS_D ));
+static yy_state_type yy_get_previous_state YY_PROTO(( void ));
+static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
+static int yy_get_next_buffer YY_PROTO(( void ));
 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
 %*
 
-#undef TSRMLS_D
-#undef TSRMLS_DC
-#undef TSRMLS_C
-#undef TSRMLS_CC
-
 /* Done after the current pattern has been matched and before the
  * corresponding action - sets up yytext.
  */
@@ -339,17 +297,6 @@ static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
 %% code to copy yytext_ptr to yytext[] goes here, if %array
 	yy_c_buf_p = yy_cp;
 
-#undef yyleng
-#undef yytext
-#undef yytext_ptr
-#undef yyin
-#undef yyout
-#undef yy_last_accepting_state
-#undef yy_last_accepting_cpos
-#undef yy_more_flag
-#undef yy_more_len
-
-
 %% data tables for the DFA and the user's section 1 definitions go here
 
 /* Macros after this point can all be overridden by user definitions in
@@ -366,7 +313,7 @@ extern int yywrap YY_PROTO(( void ));
 
 %-
 #ifndef YY_NO_UNPUT
-static void yyunput YY_PROTO(( int c, char *buf_ptr TSRMLS_DC ));
+static void yyunput YY_PROTO(( int c, char *buf_ptr ));
 #endif
 %*
 
@@ -381,30 +328,25 @@ static int yy_flex_strlen YY_PROTO(( yyconst char * ));
 #ifndef YY_NO_INPUT
 %- Standard (non-C++) definition
 #ifdef __cplusplus
-static int 3 YY_PROTO(( TSRMLS_D ));
+static int yyinput YY_PROTO(( void ));
 #else
-static int input YY_PROTO(( TSRMLS_D ));
+static int input YY_PROTO(( void ));
 #endif
 %*
 #endif
 
 #if YY_STACK_USED
-#define yy_start_stack_ptr SCNG(yy_start_stack_ptr)
-#define yy_start_stack_depth SCNG(yy_start_stack_depth)
-#define yy_start_stack SCNG(yy_start_stack)
-/*
 static int yy_start_stack_ptr = 0;
 static int yy_start_stack_depth = 0;
 static int *yy_start_stack = 0;
-*/
 #ifndef YY_NO_PUSH_STATE
-static void yy_push_state YY_PROTO(( int new_state TSRMLS_DC ));
+static void yy_push_state YY_PROTO(( int new_state ));
 #endif
 #ifndef YY_NO_POP_STATE
-static void yy_pop_state YY_PROTO(( TSRMLS_D ));
+static void yy_pop_state YY_PROTO(( void ));
 #endif
 #ifndef YY_NO_TOP_STATE
-static int yy_top_state YY_PROTO(( TSRMLS_D ));
+static int yy_top_state YY_PROTO(( void ));
 #endif
 
 #else
@@ -435,29 +377,12 @@ YY_MALLOC_DECL
 
 /* Copy whatever the last rule matched to the standard output. */
 
-/* Zend file handle reading */
-#ifndef ECHO
-#define ECHO /* There is no output */
-#endif
-
-#ifdef ZEND_MULTIBYTE
-# define YY_INPUT(buf, result, max_size) \
-	if ( ((result = zend_multibyte_yyinput(yyin, buf, max_size TSRMLS_CC)) == 0) \
-		&& zend_stream_ferror( yyin TSRMLS_CC) ) \
-		YY_FATAL_ERROR( "input in flex scanner failed" );
-#else
-# define YY_INPUT(buf, result, max_size) \
-	if ( ((result = zend_stream_read(yyin, buf, max_size TSRMLS_CC)) == 0) \
-		  && zend_stream_ferror( yyin TSRMLS_CC) ) \
-		YY_FATAL_ERROR( "input in flex scanner failed" );
-#endif
-
 #ifndef ECHO
 %- Standard (non-C++) definition
 /* This used to be an fputs(), but since the string might contain NUL's,
  * we now use fwrite().
  */
-#define ECHO (void) fwrite( yytext, yyleng, 1, SCNG(yy_out) )
+#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
 %+ C++ definition
 #define ECHO LexerOutput( yytext, yyleng )
 %*
@@ -497,7 +422,6 @@ YY_MALLOC_DECL
 %*
 #endif
 
-
 /* Default declaration of generated scanner - a define so the user can
  * easily add parameters.
  */
@@ -542,27 +466,25 @@ YY_DECL
 		if ( ! yy_start )
 			yy_start = 1;	/* first start state */
 
-#if 0
-		if ( ! SCNG(yy_in) )
+		if ( ! yyin )
 %-
-			SCNG(yy_in) = stdin;
+			yyin = stdin;
 %+
-			SCNG(yy_in) = &cin;
+			yyin = &cin;
 %*
 
-		if ( ! SCNG(yy_out) )
+		if ( ! yyout )
 %-
-			SCNG(yy_out) = stdout;
+			yyout = stdout;
 %+
-			SCNG(yy_out) = &cout;
+			yyout = &cout;
 %*
-#endif
 
 		if ( ! yy_current_buffer )
 			yy_current_buffer =
-				yy_create_buffer( SCNG(yy_in), YY_BUF_SIZE TSRMLS_CC );
+				yy_create_buffer( yyin, YY_BUF_SIZE );
 
-		yy_load_buffer_state(TSRMLS_C);
+		yy_load_buffer_state();
 		}
 
 	while ( 1 )		/* loops until end-of-file is reached */
@@ -614,8 +536,8 @@ do_action:	/* This label is used only to access EOF actions. */
 			 * this is the first action (other than possibly a
 			 * back-up) that will match for the new input source.
 			 */
-			SCNG(yy_n_chars) = yy_current_buffer->yy_n_chars;
-			yy_current_buffer->yy_input_file = SCNG(yy_in);
+			yy_n_chars = yy_current_buffer->yy_n_chars;
+			yy_current_buffer->yy_input_file = yyin;
 			yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
 			}
 
@@ -626,13 +548,13 @@ do_action:	/* This label is used only to access EOF actions. */
 		 * end-of-buffer state).  Contrast this with the test
 		 * in input().
 		 */
-		if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[SCNG(yy_n_chars)] )
+		if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
 			{ /* This was really a NUL. */
 			yy_state_type yy_next_state;
 
 			yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
 
-			yy_current_state = yy_get_previous_state(TSRMLS_C);
+			yy_current_state = yy_get_previous_state();
 
 			/* Okay, we're now positioned to make the NUL
 			 * transition.  We couldn't have
@@ -643,7 +565,7 @@ do_action:	/* This label is used only to access EOF actions. */
 			 * will run more slowly).
 			 */
 
-			yy_next_state = yy_try_NUL_trans( yy_current_state TSRMLS_CC );
+			yy_next_state = yy_try_NUL_trans( yy_current_state );
 
 			yy_bp = yytext_ptr + YY_MORE_ADJ;
 
@@ -662,7 +584,7 @@ do_action:	/* This label is used only to access EOF actions. */
 				}
 			}
 
-		else switch ( yy_get_next_buffer(TSRMLS_C) )
+		else switch ( yy_get_next_buffer() )
 			{
 			case EOB_ACT_END_OF_FILE:
 				{
@@ -697,7 +619,7 @@ do_action:	/* This label is used only to access EOF actions. */
 				yy_c_buf_p =
 					yytext_ptr + yy_amount_of_matched_text;
 
-				yy_current_state = yy_get_previous_state(TSRMLS_C);
+				yy_current_state = yy_get_previous_state();
 
 				yy_cp = yy_c_buf_p;
 				yy_bp = yytext_ptr + YY_MORE_ADJ;
@@ -705,9 +627,9 @@ do_action:	/* This label is used only to access EOF actions. */
 
 			case EOB_ACT_LAST_MATCH:
 				yy_c_buf_p =
-				&yy_current_buffer->yy_ch_buf[SCNG(yy_n_chars)];
+				&yy_current_buffer->yy_ch_buf[yy_n_chars];
 
-				yy_current_state = yy_get_previous_state(TSRMLS_C);
+				yy_current_state = yy_get_previous_state();
 
 				yy_cp = yy_c_buf_p;
 				yy_bp = yytext_ptr + YY_MORE_ADJ;
@@ -726,8 +648,8 @@ do_action:	/* This label is used only to access EOF actions. */
 %+
 yyFlexLexer::yyFlexLexer( istream* arg_yyin, ostream* arg_yyout )
 	{
-	SCNG(yy_in) = arg_yyin;
-	SCNG(yy_out) = arg_yyout;
+	yyin = arg_yyin;
+	yyout = arg_yyout;
 	yy_c_buf_p = 0;
 	yy_init = 1;
 	yy_start = 0;
@@ -756,49 +678,54 @@ yyFlexLexer::yyFlexLexer( istream* arg_yyin, ostream* arg_yyout )
 yyFlexLexer::~yyFlexLexer()
 	{
 	delete yy_state_buf;
-	yy_delete_buffer( yy_current_buffer TSRMLS_CC );
+	yy_delete_buffer( yy_current_buffer );
 	}
 
 void yyFlexLexer::switch_streams( istream* new_in, ostream* new_out )
 	{
 	if ( new_in )
 		{
-		yy_delete_buffer( SCNG(yy_current_buffer TSRMLS_CC ) );
-		yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE TSRMLS_CC ) TSRMLS_CC );
+		yy_delete_buffer( yy_current_buffer );
+		yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE ) );
 		}
 
 	if ( new_out )
-		SCNG(yy_out) = new_out;
+		yyout = new_out;
 	}
 
+#ifdef YY_INTERACTIVE
+int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )
+#else
 int yyFlexLexer::LexerInput( char* buf, int max_size )
+#endif
 	{
-		if ( SCNG(yy_in)->eof() || SCNG(yy_in)->fail() )
-			return 0;
+	if ( yyin->eof() || yyin->fail() )
+		return 0;
 
-		if (yy_current_buffer->yy_is_interactive) {
-			SCNG(yy_in)->get( buf[0] );
+#ifdef YY_INTERACTIVE
+	yyin->get( buf[0] );
 
-			if ( SCNG(yy_in)->eof() )
-				return 0;
+	if ( yyin->eof() )
+		return 0;
 
-			if ( SCNG(yy_in)->bad() )
-				return -1;
+	if ( yyin->bad() )
+		return -1;
 
-			return 1;
-		} else {
-			(void) SCNG(yy_in)->read( buf, max_size );
+	return 1;
 
-			if ( SCNG(yy_in)->bad() )
-				return -1;
-			else
-				return SCNG(yy_in)->gcount();
-		}
+#else
+	(void) yyin->read( buf, max_size );
+
+	if ( yyin->bad() )
+		return -1;
+	else
+		return yyin->gcount();
+#endif
 	}
 
 void yyFlexLexer::LexerOutput( const char* buf, int size )
 	{
-	(void) SCNG(yy_out)->write( buf, size );
+	(void) yyout->write( buf, size );
 	}
 %*
 
@@ -811,9 +738,9 @@ void yyFlexLexer::LexerOutput( const char* buf, int size )
  */
 
 %-
-static int yy_get_next_buffer(TSRMLS_D)
+static int yy_get_next_buffer()
 %+
-int yyFlexLexer::yy_get_next_buffer(TSRMLS_D)
+int yyFlexLexer::yy_get_next_buffer()
 %*
 	{
 	register char *dest = yy_current_buffer->yy_ch_buf;
@@ -821,7 +748,7 @@ int yyFlexLexer::yy_get_next_buffer(TSRMLS_D)
 	register int number_to_move, i;
 	int ret_val;
 
-	if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[SCNG(yy_n_chars) + 1] )
+	if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
 		YY_FATAL_ERROR(
 		"fatal flex scanner internal error--end of buffer missed" );
 
@@ -856,7 +783,7 @@ int yyFlexLexer::yy_get_next_buffer(TSRMLS_D)
 		/* don't do the read, it's not guaranteed to return an EOF,
 		 * just force an EOF
 		 */
-		yy_current_buffer->yy_n_chars = SCNG(yy_n_chars) = 0;
+		yy_current_buffer->yy_n_chars = yy_n_chars = 0;
 
 	else
 		{
@@ -910,17 +837,17 @@ int yyFlexLexer::yy_get_next_buffer(TSRMLS_D)
 
 		/* Read in more data. */
 		YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
-			SCNG(yy_n_chars), num_to_read );
+			yy_n_chars, num_to_read );
 
-		yy_current_buffer->yy_n_chars = SCNG(yy_n_chars);
+		yy_current_buffer->yy_n_chars = yy_n_chars;
 		}
 
-	if ( SCNG(yy_n_chars) == 0 )
+	if ( yy_n_chars == 0 )
 		{
 		if ( number_to_move == YY_MORE_ADJ )
 			{
 			ret_val = EOB_ACT_END_OF_FILE;
-			yyrestart( SCNG(yy_in) TSRMLS_CC );
+			yyrestart( yyin );
 			}
 
 		else
@@ -934,9 +861,9 @@ int yyFlexLexer::yy_get_next_buffer(TSRMLS_D)
 	else
 		ret_val = EOB_ACT_CONTINUE_SCAN;
 
-	SCNG(yy_n_chars) += number_to_move;
-	yy_current_buffer->yy_ch_buf[SCNG(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
-	yy_current_buffer->yy_ch_buf[SCNG(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
+	yy_n_chars += number_to_move;
+	yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
+	yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
 
 	yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
 
@@ -947,9 +874,9 @@ int yyFlexLexer::yy_get_next_buffer(TSRMLS_D)
 /* yy_get_previous_state - get the state just before the EOB char was reached */
 
 %-
-static yy_state_type yy_get_previous_state(TSRMLS_D)
+static yy_state_type yy_get_previous_state()
 %+
-yy_state_type yyFlexLexer::yy_get_previous_state(TSRMLS_D)
+yy_state_type yyFlexLexer::yy_get_previous_state()
 %*
 	{
 	register yy_state_type yy_current_state;
@@ -974,16 +901,13 @@ yy_state_type yyFlexLexer::yy_get_previous_state(TSRMLS_D)
 
 %-
 #ifdef YY_USE_PROTOS
-static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state TSRMLS_DC )
+static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
 #else
-static yy_state_type yy_try_NUL_trans( yy_current_state TSRMLS_CC )
+static yy_state_type yy_try_NUL_trans( yy_current_state )
 yy_state_type yy_current_state;
-#ifdef ZTS
-void ***tsrm_ls;
-#endif
 #endif
 %+
-yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state TSRMLS_DC )
+yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
 %*
 	{
 	register int yy_is_jam;
@@ -996,17 +920,14 @@ yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state TSRM
 %-
 #ifndef YY_NO_UNPUT
 #ifdef YY_USE_PROTOS
-static void yyunput( int c, register char *yy_bp TSRMLS_DC )
+static void yyunput( int c, register char *yy_bp )
 #else
-static void yyunput( c, yy_bp TSRMLS_CC )
+static void yyunput( c, yy_bp )
 int c;
 register char *yy_bp;
-#ifdef ZTS
-void ***tsrm_ls;
-#endif
 #endif
 %+
-void yyFlexLexer::yyunput( int c, register char* yy_bp TSRMLS_DC )
+void yyFlexLexer::yyunput( int c, register char* yy_bp )
 %*
 	{
 	register char *yy_cp = yy_c_buf_p;
@@ -1017,7 +938,7 @@ void yyFlexLexer::yyunput( int c, register char* yy_bp TSRMLS_DC )
 	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
 		{ /* need to shift things up to make room */
 		/* +2 for EOB chars. */
-		register int number_to_move = SCNG(yy_n_chars) + 2;
+		register int number_to_move = yy_n_chars + 2;
 		register char *dest = &yy_current_buffer->yy_ch_buf[
 					yy_current_buffer->yy_buf_size + 2];
 		register char *source =
@@ -1029,7 +950,7 @@ void yyFlexLexer::yyunput( int c, register char* yy_bp TSRMLS_DC )
 		yy_cp += (int) (dest - source);
 		yy_bp += (int) (dest - source);
 		yy_current_buffer->yy_n_chars =
-			SCNG(yy_n_chars) = yy_current_buffer->yy_buf_size;
+			yy_n_chars = yy_current_buffer->yy_buf_size;
 
 		if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
 			YY_FATAL_ERROR( "flex scanner push-back overflow" );
@@ -1050,15 +971,12 @@ void yyFlexLexer::yyunput( int c, register char* yy_bp TSRMLS_DC )
 
 %-
 #ifdef __cplusplus
-static int yyinput(TSRMLS_D)
+static int yyinput()
 #else
-static int input(TSRMLS_C)
-#ifdef ZTS
-void ***tsrm_ls;
-#endif
+static int input()
 #endif
 %+
-int yyFlexLexer::yyinput(TSRMLS_D)
+int yyFlexLexer::yyinput()
 %*
 	{
 	int c;
@@ -1071,7 +989,7 @@ int yyFlexLexer::yyinput(TSRMLS_D)
 		 * If this occurs *before* the EOB characters, then it's a
 		 * valid NUL; if not, then we've hit the end of the buffer.
 		 */
-		if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[SCNG(yy_n_chars)] )
+		if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
 			/* This was really a NUL. */
 			*yy_c_buf_p = '\0';
 
@@ -1080,7 +998,7 @@ int yyFlexLexer::yyinput(TSRMLS_D)
 			int offset = yy_c_buf_p - yytext_ptr;
 			++yy_c_buf_p;
 
-			switch ( yy_get_next_buffer(TSRMLS_C) )
+			switch ( yy_get_next_buffer() )
 				{
 				case EOB_ACT_LAST_MATCH:
 					/* This happens because yy_g_n_b()
@@ -1094,7 +1012,7 @@ int yyFlexLexer::yyinput(TSRMLS_D)
 					 */
 
 					/* Reset buffer status. */
-					yyrestart( SCNG(yy_in) TSRMLS_CC );
+					yyrestart( yyin );
 
 					/* fall through */
 
@@ -1106,9 +1024,9 @@ int yyFlexLexer::yyinput(TSRMLS_D)
 					if ( ! yy_did_buffer_switch_on_eof )
 						YY_NEW_FILE;
 #ifdef __cplusplus
-					return yyinput(TSRMLS_C);
+					return yyinput();
 #else
-					return input(TSRMLS_C);
+					return input();
 #endif
 					}
 
@@ -1131,35 +1049,32 @@ int yyFlexLexer::yyinput(TSRMLS_D)
 
 %-
 #ifdef YY_USE_PROTOS
-void yyrestart( struct _zend_file_handle *input_file TSRMLS_DC )
+void yyrestart( FILE *input_file )
 #else
-void yyrestart( input_file TSRMLS_CC )
-struct _zend_file_handle *input_file;
+void yyrestart( input_file )
+FILE *input_file;
 #endif
 %+
-void yyFlexLexer::yyrestart( istream* input_file TSRMLS_DC )
+void yyFlexLexer::yyrestart( istream* input_file )
 %*
 	{
 	if ( ! yy_current_buffer )
-		yy_current_buffer = yy_create_buffer( SCNG(yy_in), YY_BUF_SIZE TSRMLS_CC );
+		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
 
-	yy_init_buffer( yy_current_buffer, input_file TSRMLS_CC );
-	yy_load_buffer_state(TSRMLS_C);
+	yy_init_buffer( yy_current_buffer, input_file );
+	yy_load_buffer_state();
 	}
 
 
 %-
 #ifdef YY_USE_PROTOS
-void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer TSRMLS_DC)
+void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
 #else
-void yy_switch_to_buffer( new_buffer TSRMLS_CC)
+void yy_switch_to_buffer( new_buffer )
 YY_BUFFER_STATE new_buffer;
-#ifdef ZTS
-void ***tsrm_ls;
-#endif
 #endif
 %+
-void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer TSRMLS_DC )
+void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
 %*
 	{
 	if ( yy_current_buffer == new_buffer )
@@ -1170,11 +1085,11 @@ void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer TSRMLS_DC )
 		/* Flush out information for old buffer. */
 		*yy_c_buf_p = yy_hold_char;
 		yy_current_buffer->yy_buf_pos = yy_c_buf_p;
-		yy_current_buffer->yy_n_chars = SCNG(yy_n_chars);
+		yy_current_buffer->yy_n_chars = yy_n_chars;
 		}
 
 	yy_current_buffer = new_buffer;
-	yy_load_buffer_state(TSRMLS_C);
+	yy_load_buffer_state();
 
 	/* We don't actually know whether we did this switch during
 	 * EOF (yywrap()) processing, but the only time this flag
@@ -1187,37 +1102,31 @@ void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer TSRMLS_DC )
 
 %-
 #ifdef YY_USE_PROTOS
-void yy_load_buffer_state( TSRMLS_D )
+void yy_load_buffer_state( void )
 #else
-void yy_load_buffer_state(TSRMLS_C)
-#ifdef ZTS
-void ***tsrm_ls;
-#endif
+void yy_load_buffer_state()
 #endif
 %+
 void yyFlexLexer::yy_load_buffer_state()
 %*
 	{
-	SCNG(yy_n_chars) = yy_current_buffer->yy_n_chars;
+	yy_n_chars = yy_current_buffer->yy_n_chars;
 	yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
-	SCNG(yy_in) = yy_current_buffer->yy_input_file;
+	yyin = yy_current_buffer->yy_input_file;
 	yy_hold_char = *yy_c_buf_p;
 	}
 
 
 %-
 #ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_create_buffer( struct _zend_file_handle *file, int size TSRMLS_DC )
+YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
 #else
-YY_BUFFER_STATE yy_create_buffer( file, size TSRMLS_CC )
-struct _zend_file_handle *file;
+YY_BUFFER_STATE yy_create_buffer( file, size )
+FILE *file;
 int size;
-#ifdef ZTS
-void ***tsrm_ls;
-#endif
 #endif
 %+
-YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( istream* file, int size TSRMLS_DC )
+YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( istream* file, int size )
 %*
 	{
 	YY_BUFFER_STATE b;
@@ -1237,7 +1146,7 @@ YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( istream* file, int size TSRMLS_DC
 
 	b->yy_is_our_buffer = 1;
 
-	yy_init_buffer( b, file TSRMLS_CC );
+	yy_init_buffer( b, file );
 
 	return b;
 	}
@@ -1245,16 +1154,13 @@ YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( istream* file, int size TSRMLS_DC
 
 %-
 #ifdef YY_USE_PROTOS
-void yy_delete_buffer( YY_BUFFER_STATE b TSRMLS_DC )
+void yy_delete_buffer( YY_BUFFER_STATE b )
 #else
-void yy_delete_buffer( b TSRMLS_CC )
+void yy_delete_buffer( b )
 YY_BUFFER_STATE b;
-#ifdef ZTS
-void ***tsrm_ls;
-#endif
 #endif
 %+
-void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b TSRMLS_DC )
+void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )
 %*
 	{
 	if ( ! b )
@@ -1271,25 +1177,27 @@ void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b TSRMLS_DC )
 
 
 %-
+#ifndef YY_ALWAYS_INTERACTIVE
+#ifndef YY_NEVER_INTERACTIVE
+extern int isatty YY_PROTO(( int ));
+#endif
+#endif
 
 #ifdef YY_USE_PROTOS
-void yy_init_buffer( YY_BUFFER_STATE b, struct _zend_file_handle *file TSRMLS_DC )
+void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
 #else
-void yy_init_buffer( b, file TSRMLS_CC )
+void yy_init_buffer( b, file )
 YY_BUFFER_STATE b;
-struct _zend_file_handle *file;
-#ifdef ZTS
-void ***tsrm_ls;
-#endif
+FILE *file;
 #endif
 
 %+
 extern "C" int isatty YY_PROTO(( int ));
-void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, istream* file TSRMLS_DC )
+void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, istream* file )
 %*
 
 	{
-	yy_flush_buffer( b TSRMLS_CC );
+	yy_flush_buffer( b );
 
 	b->yy_input_file = file;
 	b->yy_fill_buffer = 1;
@@ -1301,28 +1209,25 @@ void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, istream* file TSRMLS_DC )
 #if YY_NEVER_INTERACTIVE
 	b->yy_is_interactive = 0;
 #else
-	b->yy_is_interactive = file->handle.stream.interactive;
+	b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
 #endif
 #endif
 %+
-	b->yy_is_interactive = (file == (istream *) &cin) ? 1 : 0;
+	b->yy_is_interactive = 0;
 %*
 	}
 
 
 %-
 #ifdef YY_USE_PROTOS
-void yy_flush_buffer( YY_BUFFER_STATE b TSRMLS_DC )
+void yy_flush_buffer( YY_BUFFER_STATE b )
 #else
-void yy_flush_buffer( b TSRMLS_CC )
+void yy_flush_buffer( b )
 YY_BUFFER_STATE b;
-#ifdef ZTS
-void ***tsrm_ls;
-#endif
 #endif
 
 %+
-void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b TSRMLS_DC )
+void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b )
 %*
 	{
 	if ( ! b )
@@ -1343,7 +1248,7 @@ void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b TSRMLS_DC )
 	b->yy_buffer_status = YY_BUFFER_NEW;
 
 	if ( b == yy_current_buffer )
-		yy_load_buffer_state(TSRMLS_C);
+		yy_load_buffer_state();
 	}
 %*
 
@@ -1351,14 +1256,11 @@ void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b TSRMLS_DC )
 #ifndef YY_NO_SCAN_BUFFER
 %-
 #ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size TSRMLS_DC )
+YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
 #else
-YY_BUFFER_STATE yy_scan_buffer( base, size TSRMLS_CC )
+YY_BUFFER_STATE yy_scan_buffer( base, size )
 char *base;
 yy_size_t size;
-#ifdef ZTS
-void ***tsrm_ls;
-#endif
 #endif
 	{
 	YY_BUFFER_STATE b;
@@ -1383,7 +1285,7 @@ void ***tsrm_ls;
 	b->yy_fill_buffer = 0;
 	b->yy_buffer_status = YY_BUFFER_NEW;
 
-	yy_switch_to_buffer( b TSRMLS_CC );
+	yy_switch_to_buffer( b );
 
 	return b;
 	}
@@ -1394,20 +1296,17 @@ void ***tsrm_ls;
 #ifndef YY_NO_SCAN_STRING
 %-
 #ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str TSRMLS_DC )
+YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
 #else
-YY_BUFFER_STATE yy_scan_string( yy_str TSRMLS_CC )
+YY_BUFFER_STATE yy_scan_string( yy_str )
 yyconst char *yy_str;
-#ifdef ZTS
-void ***tsrm_ls;
-#endif
 #endif
 	{
 	int len;
 	for ( len = 0; yy_str[len]; ++len )
 		;
 
-	return yy_scan_bytes( yy_str, len TSRMLS_CC );
+	return yy_scan_bytes( yy_str, len );
 	}
 %*
 #endif
@@ -1416,14 +1315,11 @@ void ***tsrm_ls;
 #ifndef YY_NO_SCAN_BYTES
 %-
 #ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len TSRMLS_DC )
+YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
 #else
-YY_BUFFER_STATE yy_scan_bytes( bytes, len TSRMLS_CC )
+YY_BUFFER_STATE yy_scan_bytes( bytes, len )
 yyconst char *bytes;
 int len;
-#ifdef ZTS
-void ***tsrm_ls;
-#endif
 #endif
 	{
 	YY_BUFFER_STATE b;
@@ -1442,7 +1338,7 @@ void ***tsrm_ls;
 
 	buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
 
-	b = yy_scan_buffer( buf, n TSRMLS_CC);
+	b = yy_scan_buffer( buf, n );
 	if ( ! b )
 		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
 
@@ -1460,16 +1356,13 @@ void ***tsrm_ls;
 #ifndef YY_NO_PUSH_STATE
 %-
 #ifdef YY_USE_PROTOS
-static void yy_push_state( int new_state TSRMLS_DC )
+static void yy_push_state( int new_state )
 #else
-static void yy_push_state( new_state TSRMLS_CC )
+static void yy_push_state( new_state )
 int new_state;
-#ifdef ZTS
-void ***tsrm_ls;
-#endif
 #endif
 %+
-void yyFlexLexer::yy_push_state( int new_state TSRMLS_DC )
+void yyFlexLexer::yy_push_state( int new_state )
 %*
 	{
 	if ( yy_start_stack_ptr >= yy_start_stack_depth )
@@ -1500,9 +1393,9 @@ void yyFlexLexer::yy_push_state( int new_state TSRMLS_DC )
 
 #ifndef YY_NO_POP_STATE
 %-
-static void yy_pop_state(TSRMLS_D)
+static void yy_pop_state()
 %+
-void yyFlexLexer::yy_pop_state(TSRMLS_D)
+void yyFlexLexer::yy_pop_state()
 %*
 	{
 	if ( --yy_start_stack_ptr < 0 )
@@ -1515,7 +1408,7 @@ void yyFlexLexer::yy_pop_state(TSRMLS_D)
 
 #ifndef YY_NO_TOP_STATE
 %-
-static int yy_top_state(TSRMLS_D)
+static int yy_top_state()
 %+
 int yyFlexLexer::yy_top_state()
 %*

Zend/tests/bug19859.phpt

@@ -1,22 +0,0 @@
---TEST--
-Bug #19859 (__call() does not catch call_user_func_array() calls)
---SKIPIF--
-<?php if (version_compare(zend_version(), '2.0.0-dev', '<')) die('skip ZendEngine 2 is needed'); ?>
---FILE--
-<?php
-class test
-{
-  function __call($method,$args)
-  {
-    print "test::__call invoked for method '$method'\n";
-  }
-}
-$x = new test;
-$x->fake(1);
-call_user_func_array(array($x,'fake'),array(1));
-call_user_func(array($x,'fake'),2);
-?>
---EXPECT--
-test::__call invoked for method 'fake'
-test::__call invoked for method 'fake'
-test::__call invoked for method 'fake'

Zend/tests/bug20240.phpt

@@ -1,43 +0,0 @@
---TEST--
-Bug #20240 (order of destructor calls)
---SKIPIF--
-<?php if (version_compare(zend_version(), '2.0.0-dev', '<')) die('skip ZendEngine 2 is needed'); ?>
---FILE--
-<?php
-
-class test
-{
-    public $member;
-
-    function test() {
-        $this->member = 1;
-        register_shutdown_function(array($this, 'destructor'));
-    }
-
-    function destructor() {
-        print __METHOD__ . "\n";
-    }
-
-    function __destruct() {
-        print __METHOD__ . "\n";
-    }
-
-    function add() {
-        $this->member += 1;
-        print $this->member."\n";
-    }
-}
-
-$t = new test();
-
-$t->add();
-$t->add();
-
-echo "Done\n";
-?>
---EXPECT--
-2
-3
-Done
-test::destructor
-test::__destruct

Zend/tests/bug20242.phpt

@@ -1,26 +0,0 @@
---TEST--
-Bug #20242 (Method call in front of class definition)
---SKIPIF--
-<?php if (version_compare(zend_version(), '2.0.0-dev', '>=')) die('skip ZendEngine 2 does not support this'); ?>
---FILE--
-<?php
-
-// THIS IS A WON'T FIX FOR ZE2
-
-test::show_static();
-
-$t = new test;
-$t->show_method();
-
-class test {
-	static function show_static() {
-		echo "static\n";
-	}
-	function show_method() {
-		echo "method\n";
-	}
-}
-?>
---EXPECT--
-static
-method

Zend/tests/bug21478.phpt

@@ -1,37 +0,0 @@
---TEST--
-Bug #21478 (Zend/zend_alloc.c :: shutdown_memory_manager produces segfault) 
---SKIPIF--
-<?php 
-	if (version_compare(zend_version(), '2.0.0-dev', '<')) die('skip ZendEngine 2 is needed'); 
-	if (!function_exists('stream_filter_register')) die('skip stream_filter_register() not available');
-?>
---FILE--
-<?php
-class debugfilter extends php_user_filter {
-  function filter($in, $out, &$consumed, $closing) {
-    while ($bucket = stream_bucket_make_writeable($in)) {
-      $bucket->data = strtoupper($bucket->data);
-      stream_bucket_append($out, $bucket);
-      $consumed += strlen($bucket->data);
-    }
-    return PSFS_PASS_ON;
-  }
-}
-
-stream_filter_register("myfilter","debugfilter");
-
-$fp = fopen(dirname(__FILE__)."/test.txt","w");
-stream_filter_append($fp, "myfilter");
-stream_filter_append($fp, "myfilter");
-stream_filter_append($fp, "myfilter");
-fwrite($fp, "This is a test.\n");
-print "Done.\n";
-fclose($fp);
-// Uncommenting the following 'print' line causes the segfault to stop occuring
-// print "2\n";  
-readfile(dirname(__FILE__)."/test.txt");
-unlink(dirname(__FILE__)."/test.txt");
-?>
---EXPECT--
-Done.
-THIS IS A TEST.

Zend/tests/bug21888.phpt

@@ -1,39 +0,0 @@
---TEST--
-Bug #21888 (protected property and protected method of the same name)
---SKIPIF--
-<?php 
-	if (version_compare(zend_version(), '2.0.0-dev', '<')) die('skip ZendEngine 2 is needed'); 
-?>
---FILE--
-<?php
-class mom {
-
-  protected $prot = "protected property\n";
-
-  protected function prot() {
-    print "protected method\n";
-  } 
-}
-
-class child extends mom {
-  
-  public function callMom() {
-    $this->prot();
-  }
-  
-  public function viewMom() {
-    print $this->prot;
-  }
-  
-}
-
-$c = new child();
-$c->callMom();
-$c->viewMom();
-?>
---EXPECT--
-protected method
-protected property
---EXPECT--
-protected method
-protected property

Zend/tests/bug22725.phpt

@@ -1,31 +0,0 @@
---TEST--
-bug #22725 (A derived class can call a parent's protected method that calls a private method)
---SKIPIF--
-<?php if (version_compare(zend_version(), '2.0.0-dev', '<')) die('skip ZendEngine 2 needed'); ?>
---FILE--
-<?php
-class Foo {
-    private function aPrivateMethod() {
-        echo "Foo::aPrivateMethod() called.\n";
-    }
-
-    protected function aProtectedMethod() {
-        echo "Foo::aProtectedMethod() called.\n";
-        $this->aPrivateMethod();
-    }
-}
-
-class Bar extends Foo {
-    public function aPublicMethod() {
-        echo "Bar::aPublicMethod() called.\n";
-        $this->aProtectedMethod();
-    }
-}
-
-$o = new Bar;
-$o->aPublicMethod();
-?>
---EXPECT--
-Bar::aPublicMethod() called.
-Foo::aProtectedMethod() called.
-Foo::aPrivateMethod() called.

Zend/tests/bug22836.phpt

@@ -1,74 +0,0 @@
---TEST--
-Bug #22836 (returning references to NULL)
---SKIPIF--
-<?php if (version_compare(zend_version(), '2.0.0-dev', '<')) die('skip ZendEngine 2 is needed'); ?>
---FILE--
-<?php
-function &f()
-{
-	$x = "foo";
-	var_dump($x);
-	print "'$x'\n";
-	return ($a);
-}
-for ($i = 0; $i < 8; $i++) {
-	$h =& f();
-}
-?>
---EXPECTF--
-string(3) "foo"
-'foo'
-
-Notice: Undefined variable:  a in %s on line %d
-
-Strict Standards: Only variable references should be returned by reference in %s on line %d
-string(3) "foo"
-'foo'
-
-Notice: Undefined variable:  a in %s on line %d
-
-Strict Standards: Only variable references should be returned by reference in %s on line %d
-string(3) "foo"
-'foo'
-
-Notice: Undefined variable:  a in %s on line %d
-
-Strict Standards: Only variable references should be returned by reference in %s on line %d
-string(3) "foo"
-'foo'
-
-Notice: Undefined variable:  a in %s on line %d
-
-Strict Standards: Only variable references should be returned by reference in %s on line %d
-string(3) "foo"
-'foo'
-
-Notice: Undefined variable:  a in %s on line %d
-
-Strict Standards: Only variable references should be returned by reference in %s on line %d
-string(3) "foo"
-'foo'
-
-Notice: Undefined variable:  a in %s on line %d
-
-Strict Standards: Only variable references should be returned by reference in %s on line %d
-string(3) "foo"
-'foo'
-
-Notice: Undefined variable:  a in %s on line %d
-
-Strict Standards: Only variable references should be returned by reference in %s on line %d
-string(3) "foo"
-'foo'
-
-Notice: Undefined variable:  a in %s on line %d
-
-Strict Standards: Only variable references should be returned by reference in %s on line %d
-string(3) "foo"
-'foo'
-
-Notice: Undefined variable:  a in %s on line %d
-
-Strict Standards: Only variable references should be returned by reference in %s on line %d
-
-

Zend/tests/bug23104.phpt

@@ -1,12 +0,0 @@
---TEST--
-Bug #23104 (Hash position not reset for constant arrays)
---FILE--
-<?php
-function foo($bar = array("a", "b", "c"))
-{
-	var_dump(current($bar));
-}
-foo();
-?>
---EXPECT--
-string(1) "a"

Zend/tests/bug24436.phpt

@@ -1,24 +0,0 @@
---TEST--
-Bug #24436 (isset()/empty() produce errors with non-existent variables in classes)
---SKIPIF--
-<?php if (version_compare(zend_version(), '2.0.0-dev', '<')) die('skip ZendEngine 2 is needed'); ?>
---INI--
-error_reporting=2047
---FILE--
-<?php
-class test {
-        function __construct() {
-                if (empty($this->test[0][0])) { print "test1\n";}
-                if (!isset($this->test[0][0])) { print "test2\n";}
-                if (empty($this->test)) { print "test1\n";}
-                if (!isset($this->test)) { print "test2\n";}
-        }
-}
-
-$test1 = new test();
-?>
---EXPECT--
-test1
-test2
-test1
-test2

Zend/tests/bug24635.phpt

@@ -1,30 +0,0 @@
---TEST--
-Bug #24635 (crash on dtor calling other functions)
---SKIPIF--
-<?php if (version_compare(zend_version(), '2.0.0-dev', '<')) die('skip ZendEngine 2 is needed'); ?>
---FILE--
-<?php
-class SiteClass {
-	function __construct()	{ $this->page = new PageClass(); }
-}
-class PageClass {
-	function Display() {
-		$section = new SectionClass("PageClass::Display");
-	}
-}
-class SectionClass {
-	function __construct($comment) {
-		$this->Comment = $comment;
- 	}
-	function __destruct() {
-		out($this->Comment); // this line doesn't crash PHP 
- 		out("\n<!-- End Section: " . $this->Comment . "-->"); // this line
- 	}
-}
-function out($code) { return; }
-$site = new SiteClass(); 
-$site->page->Display();
-echo "OK\n";
-?>
---EXPECT--
-OK

Zend/tests/bug24699.phpt

@@ -1,13 +0,0 @@
---TEST--
-Bug #24699 (Memory Leak with per-class constants)
---SKIPIF--
-<?php if (version_compare(zend_version(), '2.0.0-dev', '<')) die('skip ZendEngine 2 is needed'); ?>
---FILE--
-<?php
-class TEST { const FOO = SEEK_CUR; };
-class TEST2 { const FOO = 1; };
-class TEST3 { const FOO = PHP_VERSION; };
-print TEST::FOO."\n";
-?>
---EXPECT--
-1

Zend/tests/bug24773.phpt

@@ -1,9 +0,0 @@
---TEST--
-Bug #24773 (unset() of integers treated as arrays causes a crash)
---FILE--
-<?php
-	$array = 'test';
-	unset($array["lvl1"]["lvl2"]["b"]);
-?>
---EXPECTF--
-Fatal error: Cannot unset string offsets in %s on line %d

Zend/tests/bug24884.phpt

@@ -1,28 +0,0 @@
---TEST--
-Bug #24884 (calling $this->__clone(); crashes php)
---SKIPIF--
-<?php if (version_compare(zend_version(), '2.0.0-dev', '<')) die('skip ZendEngine 2 needed'); ?>
---FILE--
-<?php
-class Test {
-    function __copy()
-    {
-        $string = PHP_VERSION;
-        $version = $string{0};
-        if($string < 5)
-        {
-            return $this;
-        }
-        else
-        {
-            return clone $this;
-        }
-    }
-}
-$test = new Test();
-$test2 = $test->__copy();
-var_dump($test2);
-?>
---EXPECT--
-object(Test)#2 (0) {
-}

Zend/tests/bug26010.phpt

@@ -1,19 +0,0 @@
---TEST--
-Bug #26010 (private / protected variables get exposed by get_object_vars())
---FILE--
-<?php
-class foo {
-	private $private = 'private';
-	protected $protected = 'protected';
-	public $public = 'public';
-}
-$data = new foo();
-$obj_vars = get_object_vars($data);
-var_dump($obj_vars);
-?>
---EXPECT--
-array(1) {
-  ["public"]=>
-  string(6) "public"
-}
-

Zend/tests/bug26077.phpt

@@ -1,9 +0,0 @@
---TEST--
-Bug #26077  	Memory leaks when creating an instance of an object
---FILE--
-<?php
-class foo {} new foo();
-?>
-===DONE===
---EXPECT--
-===DONE===

Zend/tests/bug26166.phpt

@@ -1,67 +0,0 @@
---TEST--
-Bug #26166 (__toString() crash when no values returned)
---FILE--
-<?php
-class Foo
-{
-    function __toString()
-    {
-        return "Hello World!\n";
-    }
-}
-
-class Bar
-{
-    private $obj;
-
-    function __construct()
-    {
-        $this->obj = new Foo();
-    }
-
-    function __toString()
-    {
-        return $this->obj->__toString();
-    }
-}
-
-$o = new Bar;
-echo $o;
-
-echo "===THROW===\n";
-
-class Error 
-{
-	function __toString() {
-		throw new Exception("This is an error!");
-	}
-}
-
-$o = new Error;
-try {
-	echo $o;
-}
-catch (Exception $e) {
-	echo "Got the exception\n";
-}
-
-echo "===NONE===\n";
-
-class None
-{
-	function __toString() {
-	}
-}
-
-$o = new None;
-echo $o;
-
-?>
-===DONE===
---EXPECTF--
-Hello World!
-===THROW===
-Got the exception
-===NONE===
-
-Fatal error: Method None::__toString() must return a string value in %sbug26166.php on line %d

Zend/tests/bug26229.phpt

@@ -1,21 +0,0 @@
---TEST--
-Bug #26229 (getIterator() segfaults when it returns arrays or scalars)
---FILE--
-<?php
-
-class array_iterator implements IteratorAggregate {
-        public function getIterator() {
-                return array('foo', 'bar');     
-        }
-}
-
-$obj = new array_iterator;
-
-foreach ($obj as $property => $value) {
-        var_dump($value);
-}
-?>
-===DONE===
---EXPECTF--
-Warning: Objects returned by array_iterator::getIterator() must be traversable or implement interface Iterator in %sbug26229.php on line %d
-===DONE===

Zend/tests/bug26281.phpt

@@ -1,13 +0,0 @@
---TEST--
-Bug #26281 (switch() crash when condition is a string offset)
---FILE--
-<?php
-	$x = 'abc';
-	switch ($x{0}) {
-		case 'a':
-			echo "no crash\n";
-			break;
-	}
-?>
---EXPECT--
-no crash

Zend/tests/bug26696.phpt

@@ -1,22 +0,0 @@
---TEST--
-Bug #26696 (crash in switch() when string index is used)
---FILE--
-<?php
-$str = 'asdd/?';
-$len = strlen($str);
-for ($i = 0; $i < $len; $i++) {
-	switch ($str[$i]) {
-	case '?':
-		echo "?+\n";
-		break;
-	default:
-		echo $str[$i].'-';
-		break;
-	}
-}
-
-?>
-===DONE===
---EXPECT--
-a-s-d-d-/-?+
-===DONE===

Zend/tests/bug26697.phpt

@@ -1,24 +0,0 @@
---TEST--
-Bug #26697 (calling class_exists on a nonexistent class in __autoload results in segfault)
---SKIPIF--
-<?php if (function_exists('__autoload')) die('skip __autoload() declared in auto_prepend_file');?>
---FILE--
-<?php
-
-function __autoload($name)
-{
-	echo __METHOD__ . "($name)\n";
-	var_dump(class_exists('NotExistingClass'));
-	echo __METHOD__ . "($name), done\n";
-}
-
-var_dump(class_exists('NotExistingClass'));
-
-?>
-===DONE===
---EXPECTF--
-__autoload(NotExistingClass)
-bool(false)
-__autoload(NotExistingClass), done
-bool(false)
-===DONE===

Zend/tests/bug26698.phpt

@@ -1,73 +0,0 @@
---TEST--
-Bug #26698 (Thrown exceptions while evaluting argument to pass as parameter crash PHP)
---FILE--
-<?php
-
-ini_set("report_memleaks", 0);  // the exception thrown in this test results in a memory leak, which is fine
-
-class Object
-{
-	function getNone()
-	{
-		throw new Exception('NONE');
-	}
-}
-
-class Proxy
-{
-	function three($a, $b, $c)
-	{
-	}
-
-	function callOne()
-	{
-		try
-		{
-			$res = new Object();
-			$this->three($res->getNone());
-		}
-		catch(Exception $e)
-		{
-			echo 'Caught: '.$e->getMessage()."\n";
-		}
-	}
-
-	function callTwo()
-	{
-		try
-		{
-			$res = new Object();
-			$this->three(1, $res->getNone());
-		}
-		catch(Exception $e)
-		{
-			echo 'Caught: '.$e->getMessage()."\n";
-		}
-	}
-
-	function callThree()
-	{
-		try
-		{
-			$res = new Object();
-			$this->three(1, 2, $res->getNone());
-		}
-		catch(Exception $e)
-		{
-			echo 'Caught: '.$e->getMessage()."\n";
-		}
-	}
-}
-
-$p = new Proxy();
-
-$p->callOne();
-$p->callTwo();
-$p->callThree();
-?>
-===DONE===
---EXPECT--
-Caught: NONE
-Caught: NONE
-Caught: NONE
-===DONE===

Zend/tests/bug26801.phpt

@@ -1,22 +0,0 @@
---TEST--
-Bug #26801 (switch ($a{0}) crash)
---FILE--
-<?php
-
-$a = '11';
-$b = $a{0};
-switch ($b) {
-	case '-':
-		break;
-}
-
-$a = '22';
-switch ($a{0}) {
-	case '-':
-		break;
-}
-
-?>
-===DONE===
---EXPECT--
-===DONE===

Zend/tests/bug26802.phpt

@@ -1,37 +0,0 @@
---TEST--
-Bug #26802 (Can't call static method using a variable)
---FILE--
-<?php
-
-function global_func()
-{
-	echo __METHOD__ . "\n";
-}
-
-$function = 'global_func';
-$function();
-
-class foo
-{
-	static $method = 'global_func';
-	
-	static public function foo_func()
-	{
-		echo __METHOD__ . "\n";
-	}
-}
-
-/* The following is a BC break with PHP 4 where it would 
- * call foo::fail. In PHP 5 we first evaluate static class 
- * properties and then do the function call.
- */
-$method = 'foo_func';
-foo::$method();
-
-
-?>
-===DONE===
---EXPECT--
-global_func
-foo::foo_func
-===DONE===

Zend/tests/bug27145.phpt

@@ -1,13 +0,0 @@
---TEST--
-Bug #27145 (Errors messages print unmangled PPP property names)
---FILE--
-<?php
-class a {
-	protected static $v = "aa";
-}
-class b extends a {
-	protected static $v = "bb";
-}
-?>
---EXPECTF--
-Fatal error: Cannot redeclare property static protected a::$v in class b in %s on line %d

Zend/tests/bug27641.phpt

@@ -1,42 +0,0 @@
---TEST--
-Bug #27641 (zend.ze1_compatibility_mode = On causes object properties to be misreported)
---SKIPIF--
-<?php if (version_compare(zend_version(), '2.0.0-dev', '<')) die('skip ZendEngine 2 is needed'); ?>
---FILE--
-<?php
-  class A {
-    public $a = "Default for A";
-    public $b = "Default for B";
-
-    function __construct($a, $b) {
-      $this->a = $a;
-      $this->b = $b;
-    }
-    function A() {
-      $args = func_get_args();
-      call_user_func_array(Array(&$this, '__construct'), $args);
-    }
-  }
-
-  $t = new A("New A", "New B");
-  print_r($t);
-  print_r(get_class_vars(get_class($t)));
-  print_r(get_object_vars($t));
-?>
---EXPECTF--
-Strict Standards: Redefining already defined constructor for class A in %sbug27641.php on line %d
-A Object
-(
-    [a] => New A
-    [b] => New B
-)
-Array
-(
-    [a] => Default for A
-    [b] => Default for B
-)
-Array
-(
-    [a] => New A
-    [b] => New B
-)

Zend/tests/bug27731.phpt

@@ -1,10 +0,0 @@
---TEST--
-Bug #27731 (error_reporing() call inside @ block does not work correctly)
---FILE--
-<?php
-	error_reporting(E_ALL ^ E_NOTICE);
-	@error_reporting(E_WARNING);
-	var_dump(error_reporting());
-?>
---EXPECT--
-int(2)

Zend/tests/bug29505.phpt

@@ -1,31 +0,0 @@
---TEST--
-Bug #29505 (get_class_vars() severely broken when used with arrays)
---FILE--
-<?php
-
-class Test {
-    public $empty = array();
-    public $three = array(1, "b"=>"c", 3=>array());
-}
-
-var_dump(get_class_vars('Test'));
-
-?>
-===DONE===
---EXPECT--
-array(2) {
-  ["empty"]=>
-  array(0) {
-  }
-  ["three"]=>
-  array(3) {
-    [0]=>
-    int(1)
-    ["b"]=>
-    string(1) "c"
-    [3]=>
-    array(0) {
-    }
-  }
-}
-===DONE===

Zend/tests/dtor_scope.phpt

@@ -1,34 +0,0 @@
---TEST--
-Scoping in destructor call
---SKIPIF--
-<?php if (version_compare(zend_version(), '2.0.0-dev', '<')) die('skip ZendEngine 2 needed'); ?>
---FILE--
-<?php
-        class T
-        {
-                private $var = array();
-
-                public function add($a)
-                {
-                        array_push($this->var, $a);
-                }
-
-                public function __destruct()
-                {
-                        print_r($this->var);
-                }
-        }
-
-        class TT extends T
-        {
-        }
-        $t = new TT();
-        $t->add("Hello");
-        $t->add("World");
-?>
---EXPECT--
-Array
-(
-    [0] => Hello
-    [1] => World
-)

Zend/tests/zend2.php.txt

@@ -1,275 +0,0 @@
-Example 1: A singleton (static members)
-=======================================
-
-<?php
-
-	class Counter {
-		var $counter = 0;
-		
-		function increment_and_print()
-		{
-				print ++$this->counter;
-				print "\n";
-		}	
-	}
-	
-	
-	class SingletonCounter {
-		static $m_instance = NULL;
-		
-		function Instance()
-		{
-				if (self::$m_instance == NULL) {
-					self::$m_instance = new Counter();
-				}
-				return self::$m_instance;
-		}	
-	}
-	
-	SingletonCounter::Instance()->increment_and_print();
-	SingletonCounter::Instance()->increment_and_print();
-	SingletonCounter::Instance()->increment_and_print();
-	
-?>
-
-Example 2: Factory method (derefencing objects returned from functions)
-=======================================================================
-
-<?php
-	
-	class Circle {
-		function draw()
-		{
-			print "Circle\n";	
-		}
-	}
-	
-	class Square {
-		function draw()
-		{
-			print "Square\n";	
-		}
-	}
-	
-	function ShapeFactoryMethod($shape)
-	{
-		switch ($shape) {
-			case "Circle":
-				return new Circle();
-			case "Square":
-				return new Square();
-		}	
-	}
-	
-	ShapeFactoryMethod("Circle")->draw();
-	ShapeFactoryMethod("Square")->draw();
-	
-	
-?>
-
-Example 3: Class constants and class scope
-==========================================
-
-<?php
-
-	class ErrorCodes {
-		const FATAL = "Fatal error\n";
-		const WARNING = "Warning\n";
-		const INFO = "Informational message\n";
-		
-		function print_fatal_error_codes()
-		{
-			print "FATAL = " . FATAL;
-			print "self::FATAL = " . self::FATAL;
-		}
-	}
-	
-	/* Call the static function and move into the ErrorCodes scope */
-	ErrorCodes::print_fatal_error_codes();
-
-?>
-
-Example 4: Regular object method using both local and global functions
-======================================================================
-
-<?php
-
-	class HelloWorld {
-		const HELLO_WORLD = "Hello, World!\n";
-		
-		function get_hello_world()
-		{
-			return HELLO_WORLD;
-		}
-		
-		function length_of_hello_world()
-		{
-			$str = $this->get_hello_world();
-			return strlen($str);
-		}	
-	}
-	
-	$obj = new HelloWorld();
-	print "length_of_hello_world() = " . $obj->length_of_hello_world();
-	print "\n";
-?>
-
-Example 5: Multiple derefencing of objects returned from methods
-================================================================
-
-<?php
-
-
-	class Name {
-		function Name($_name)
-		{
-			$this->name = $_name;	
-		}
-		
-		function display()
-		{
-			print $this->name;
-			print "\n";
-		}
-	}
-	
-	class Person {
-		function Person($_name, $_address)
-		{
-			$this->name = new Name($_name);
-		}
-		
-		function getName()
-		{
-			return $this->name;	
-		}
-	}	
-
-	$person = new Person("John", "New York");
-	$person->getName()->display();
-	
-?>
-
-Example 6: Exception handling
-=============================
-
-<?
-	class MyException {
-		function MyException($_error) {
-			$this->error = $_error;	
-		}
-		
-		function getException()
-		{
-			return $this->error;	
-		}
-	}
-	
-	function ThrowException()
-	{
-		throw new MyException("'This is an exception!'");	
-	}
-	
-	
-	try {
-	} catch (MyException $exception) {
-		print "There was an exception: " . $exception->getException();
-		print "\n";
-	}
-	
-	try {
-		ThrowException();	
-	} catch (MyException $exception) {
-		print "There was an exception: " . $exception->getException();
-		print "\n";
-	}
-	
-?>
-
-Example 7: __clone()
-===================
-
-<?
-	class MyCloneable {
-		static $id = 0;
-		
-		function MyCloneable()
-		{
-			$this->id = self::$id++;
-		}
-		
-		function __clone()
-		{
-			$this->name = $that->name;
-			$this->address = "New York";
-			$this->id = self::$id++;
-		}
-	}
-	
-
-	
-	$obj = new MyCloneable();
-
-	$obj->name = "Hello";
-	$obj->address = "Tel-Aviv";
-	
-	print $obj->id;
-	print "\n";
-	
-	$obj = $obj->__clone();
-	
-	print $obj->id;
-	print "\n";
-	print $obj->name;
-	print "\n";
-	print $obj->address;
-	print "\n";
-?>
-
-Example 8: Unified constructors
-===============================
-
-<?
-
-	class BaseClass {
-		function __construct()
-		{
-			print "In BaseClass constructor\n";	
-		}
-	}
-	
-	class SubClass extends BaseClass {
-		function __construct()
-		{
-				parent::__construct();
-				print "In SubClass constructor\n";	
-		}
-	}
-	
-	$obj = new BaseClass();
-	
-	$obj = new SubClass();
-	
-?>
-
-Example 9: Destructors
-=======================
-
-<?php
-
-class MyDestructableClass {
-	function __construct()
-	{
-		print "In constructor\n";
-		$this->name = "MyDestructableClass";
-	}	
-	
-	function __destruct()
-	{
-		print "Destroying " . $this->name . "\n";
-	}	
-}
-
-$obj = new MyDestructableClass();
-
-?>

Zend/tests/zend_operators.phpt

@@ -1,12 +0,0 @@
---TEST--
-Operator precedence
---FILE--
-<?php /* $Id$ */
-
-var_dump((object)1 instanceof stdClass);
-var_dump(! (object)1 instanceof Exception);
-
-?>
---EXPECT--
-bool(true)
-bool(true)

Zend/zend-parser.y

@@ -0,0 +1,725 @@
+%{
+/*
+   +----------------------------------------------------------------------+
+   | 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  { do_extended_info(CLS_C); } top_statement { HANDLE_INTERACTIVE(); }
+	|	/* empty */
+;
+
+
+top_statement:
+		statement
+	|	declaration_statement	{ do_early_binding(CLS_C); }
+;
+
+
+inner_statement_list:
+		inner_statement_list  { do_extended_info(CLS_C); } inner_statement { HANDLE_INTERACTIVE(); }
+	|	/* empty */
+;
+
+
+inner_statement:
+		statement
+	|	declaration_statement
+;
+
+
+statement:
+		unticked_statement { do_ticks(CLS_C); }
+;
+
+
+unticked_statement:
+		'{' inner_statement_list '}'
+	|	T_IF '(' expr ')' { do_if_cond(&$3, &$4 CLS_CC); } statement { do_if_after_statement(&$4, 1 CLS_CC); } elseif_list else_single { do_if_end(CLS_C); }
+	|	T_IF '(' expr ')' ':' { do_if_cond(&$3, &$4 CLS_CC); } inner_statement_list { do_if_after_statement(&$4, 1 CLS_CC); } new_elseif_list new_else_single T_ENDIF ';' { do_if_end(CLS_C); }
+	|	T_WHILE '(' { $1.u.opline_num = get_next_op_number(CG(active_op_array));  } expr  ')' { do_while_cond(&$4, &$5 CLS_CC); } while_statement { do_while_end(&$1, &$5 CLS_CC); }
+	|	T_DO { $1.u.opline_num = get_next_op_number(CG(active_op_array));  do_do_while_begin(CLS_C); } statement T_WHILE '(' { $5.u.opline_num = get_next_op_number(CG(active_op_array)); } expr ')' ';' { do_do_while_end(&$1, &$5, &$7 CLS_CC); }
+	|	T_FOR 
+			'('
+				for_expr
+			';' { do_free(&$3 CLS_CC); $4.u.opline_num = get_next_op_number(CG(active_op_array)); }
+				for_expr
+			';' { do_extended_info(CLS_C); do_for_cond(&$6, &$7 CLS_CC); }
+				for_expr
+			')' { do_free(&$9 CLS_CC); do_for_before_statement(&$4, &$7 CLS_CC); }
+			for_statement { do_for_end(&$7 CLS_CC); }
+	|	T_SWITCH '(' expr ')'	{ do_switch_cond(&$3 CLS_CC); } switch_case_list { do_switch_end(&$6 CLS_CC); }
+	|	T_BREAK ';'				{ do_brk_cont(ZEND_BRK, NULL CLS_CC); }
+	|	T_BREAK expr ';'		{ do_brk_cont(ZEND_BRK, &$2 CLS_CC); }
+	|	T_CONTINUE ';'			{ do_brk_cont(ZEND_CONT, NULL CLS_CC); }
+	|	T_CONTINUE expr ';'		{ do_brk_cont(ZEND_CONT, &$2 CLS_CC); }
+	|	T_RETURN ';'						{ do_return(NULL, 0 CLS_CC); }
+	|	T_RETURN expr_without_variable ';'	{ do_return(&$2, 0 CLS_CC); }
+	|	T_RETURN cvar ';'					{ do_return(&$2, 1 CLS_CC); }
+	|	T_GLOBAL global_var_list ';'
+	|	T_STATIC static_var_list ';'
+	|	T_ECHO echo_expr_list ';'
+	|	T_INLINE_HTML			{ do_echo(&$1 CLS_CC); }
+	|	expr ';'				{ 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 { do_foreach_begin(&$1, &$3, &$2, &$4, 1 CLS_CC); } w_cvar foreach_optional_arg ')' { do_foreach_cont(&$6, &$7, &$4 CLS_CC); } foreach_statement { do_foreach_end(&$1, &$2 CLS_CC); }
+	|	T_FOREACH '(' expr_without_variable T_AS { do_foreach_begin(&$1, &$3, &$2, &$4, 0 CLS_CC); } w_cvar foreach_optional_arg ')' { do_foreach_cont(&$6, &$7, &$4 CLS_CC); } foreach_statement { do_foreach_end(&$1, &$2 CLS_CC); }
+	|	T_DECLARE { do_declare_begin(CLS_C); } '(' declare_list ')' declare_statement { do_declare_end(CLS_C); }
+	|	';'		/* empty statement */
+;
+
+unset_variables:
+		unset_variable
+	|	unset_variables ',' unset_variable
+;
+
+unset_variable:
+		cvar	{ do_end_variable_parse(BP_VAR_UNSET, 0 CLS_CC); do_unset(&$1 CLS_CC); }
+;
+
+use_filename:
+		T_CONSTANT_ENCAPSED_STRING			{ $$ = $1; }
+	|	'(' T_CONSTANT_ENCAPSED_STRING ')'	{ $$ = $2; }
+;
+
+
+declaration_statement:
+		unticked_declaration_statement	{ do_ticks(CLS_C); }
+;
+
+
+unticked_declaration_statement:
+		T_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING { do_begin_function_declaration(&$1, &$4, 0, $3.op_type CLS_CC); }
+			'(' parameter_list ')' '{' inner_statement_list '}' { do_end_function_declaration(&$1 CLS_CC); }
+	|	T_OLD_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING  { do_begin_function_declaration(&$1, &$4, 0, $3.op_type CLS_CC); }
+			parameter_list '(' inner_statement_list ')' ';' { do_end_function_declaration(&$1 CLS_CC); }
+	|	T_CLASS T_STRING { do_begin_class_declaration(&$2, NULL CLS_CC); } '{' class_statement_list '}' { do_end_class_declaration(CLS_C); }
+	|	T_CLASS T_STRING T_EXTENDS T_STRING { do_begin_class_declaration(&$2, &$4 CLS_CC); } '{' class_statement_list '}' { 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					{ do_declare_stmt(&$1, &$3 CLS_CC); }
+	|	declare_list ',' T_STRING '=' static_scalar	{ 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 { do_extended_info(CLS_C);  do_case_before_statement(&$1, &$2, &$3 CLS_CC); } inner_statement_list { do_case_after_statement(&$$, &$2 CLS_CC); $$.op_type = IS_CONST }
+	|	case_list T_DEFAULT case_separator { do_extended_info(CLS_C);  do_default_before_statement(&$1, &$2 CLS_CC); } inner_statement_list { 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 ')' { do_if_cond(&$4, &$5 CLS_CC); } statement { do_if_after_statement(&$5, 0 CLS_CC); }
+;
+
+
+new_elseif_list:
+		/* empty */
+	|	new_elseif_list T_ELSEIF '(' expr ')' ':' { do_if_cond(&$4, &$5 CLS_CC); } inner_statement_list { 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); 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); 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); 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); 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++; 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++; 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++; 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++; 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;  do_pass_param(&$1, ZEND_SEND_VAL, $$.u.constant.value.lval CLS_CC); }
+	|	cvar					{ $$.u.constant.value.lval = 1;  do_pass_param(&$1, ZEND_SEND_VAR, $$.u.constant.value.lval CLS_CC); }
+	|	'&' w_cvar 				{ $$.u.constant.value.lval = 1;  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;  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;  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;  do_pass_param(&$4, ZEND_SEND_REF, $$.u.constant.value.lval CLS_CC); }
+;
+
+global_var_list:
+		global_var_list ',' global_var	{ do_fetch_global_or_static_variable(&$3, NULL, ZEND_FETCH_GLOBAL CLS_CC); }
+	|	global_var						{ 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 { do_fetch_global_or_static_variable(&$3, NULL, ZEND_FETCH_STATIC CLS_CC); }
+	|	static_var_list ',' T_VARIABLE '=' static_scalar { do_fetch_global_or_static_variable(&$3, &$5, ZEND_FETCH_STATIC CLS_CC); }
+	|	T_VARIABLE  { do_fetch_global_or_static_variable(&$1, NULL, ZEND_FETCH_STATIC CLS_CC); }
+	|	T_VARIABLE '=' static_scalar { 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 { do_begin_function_declaration(&$1, &$4, 1, $3.op_type CLS_CC); } '(' 
+			parameter_list ')' '{' inner_statement_list '}' { do_end_function_declaration(&$1 CLS_CC); }
+	|	T_OLD_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING { do_begin_function_declaration(&$1, &$4, 1, $3.op_type CLS_CC); }
+			parameter_list '(' inner_statement_list ')' ';' { 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					{ do_declare_property(&$3, NULL CLS_CC); }
+	|	class_variable_decleration ',' T_VARIABLE '=' static_scalar	{ do_declare_property(&$3, &$5 CLS_CC); }
+	|	T_VARIABLE						{ do_declare_property(&$1, NULL CLS_CC); }
+	|	T_VARIABLE '=' static_scalar	{ do_declare_property(&$1, &$3 CLS_CC); }
+;
+
+
+echo_expr_list:	
+	|	echo_expr_list ',' expr { do_echo(&$3 CLS_CC); }
+	|	expr					{ 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 ','	{ do_free(&$1 CLS_CC); } expr { $$ = $4; }
+	|	expr					{ $$ = $1; }
+;
+
+
+expr_without_variable:	
+		T_LIST '(' { do_list_init(CLS_C); } assignment_list ')' '=' expr { do_list_end(&$$, &$7 CLS_CC); }
+	|	cvar '=' expr		{ do_end_variable_parse(BP_VAR_W, 0 CLS_CC); do_assign(&$$, &$1, &$3 CLS_CC); }
+	|	cvar '=' '&' w_cvar	{ do_end_variable_parse(BP_VAR_W, 0 CLS_CC); do_assign_ref(&$$, &$1, &$4 CLS_CC); }
+	|	cvar '=' '&' function_call { do_end_variable_parse(BP_VAR_W, 0 CLS_CC); do_assign_ref(&$$, &$1, &$4 CLS_CC); }
+	|	T_NEW class_name { do_extended_fcall_begin(CLS_C); do_begin_new_object(&$1, &$2 CLS_CC); } ctor_arguments { do_end_new_object(&$$, &$2, &$1, &$4 CLS_CC); do_extended_fcall_end(CLS_C);}
+	|	cvar T_PLUS_EQUAL expr 	{ do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); do_binary_assign_op(ZEND_ASSIGN_ADD, &$$, &$1, &$3 CLS_CC); }
+	|	cvar T_MINUS_EQUAL expr	{ do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); do_binary_assign_op(ZEND_ASSIGN_SUB, &$$, &$1, &$3 CLS_CC); }
+	|	cvar T_MUL_EQUAL expr		{ do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); do_binary_assign_op(ZEND_ASSIGN_MUL, &$$, &$1, &$3 CLS_CC); }
+	|	cvar T_DIV_EQUAL expr		{ do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); do_binary_assign_op(ZEND_ASSIGN_DIV, &$$, &$1, &$3 CLS_CC); }
+	|	cvar T_CONCAT_EQUAL expr	{ do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); do_binary_assign_op(ZEND_ASSIGN_CONCAT, &$$, &$1, &$3 CLS_CC); }
+	|	cvar T_MOD_EQUAL expr		{ do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); do_binary_assign_op(ZEND_ASSIGN_MOD, &$$, &$1, &$3 CLS_CC); }
+	|	cvar T_AND_EQUAL expr		{ do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); do_binary_assign_op(ZEND_ASSIGN_BW_AND, &$$, &$1, &$3 CLS_CC); }
+	|	cvar T_OR_EQUAL expr 		{ do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); do_binary_assign_op(ZEND_ASSIGN_BW_OR, &$$, &$1, &$3 CLS_CC); }
+	|	cvar T_XOR_EQUAL expr 		{ do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); do_binary_assign_op(ZEND_ASSIGN_BW_XOR, &$$, &$1, &$3 CLS_CC); }
+	|	cvar T_SL_EQUAL expr	{ do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); do_binary_assign_op(ZEND_ASSIGN_SL, &$$, &$1, &$3 CLS_CC); } 
+	|	cvar T_SR_EQUAL expr	{ do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); do_binary_assign_op(ZEND_ASSIGN_SR, &$$, &$1, &$3 CLS_CC); } 
+	|	rw_cvar T_INC { do_post_incdec(&$$, &$1, ZEND_POST_INC CLS_CC); }
+	|	T_INC rw_cvar { do_pre_incdec(&$$, &$2, ZEND_PRE_INC CLS_CC); }
+	|	rw_cvar T_DEC { do_post_incdec(&$$, &$1, ZEND_POST_DEC CLS_CC); }
+	|	T_DEC rw_cvar { do_pre_incdec(&$$, &$2, ZEND_PRE_DEC CLS_CC); }
+	|	expr T_BOOLEAN_OR { do_boolean_or_begin(&$1, &$2 CLS_CC); } expr { do_boolean_or_end(&$$, &$1, &$4, &$2 CLS_CC); }
+	|	expr T_BOOLEAN_AND { do_boolean_and_begin(&$1, &$2 CLS_CC); } expr { do_boolean_and_end(&$$, &$1, &$4, &$2 CLS_CC); }  
+	|	expr T_LOGICAL_OR { do_boolean_or_begin(&$1, &$2 CLS_CC); } expr { do_boolean_or_end(&$$, &$1, &$4, &$2 CLS_CC); }
+	|	expr T_LOGICAL_AND { do_boolean_and_begin(&$1, &$2 CLS_CC); } expr { do_boolean_and_end(&$$, &$1, &$4, &$2 CLS_CC); }
+	|	expr T_LOGICAL_XOR expr { do_binary_op(ZEND_BOOL_XOR, &$$, &$1, &$3 CLS_CC); }
+	|	expr '|' expr	{ do_binary_op(ZEND_BW_OR, &$$, &$1, &$3 CLS_CC); }
+	|	expr '&' expr	{ do_binary_op(ZEND_BW_AND, &$$, &$1, &$3 CLS_CC); }
+	|	expr '^' expr	{ do_binary_op(ZEND_BW_XOR, &$$, &$1, &$3 CLS_CC); }
+	|	expr '.' expr 	{ do_binary_op(ZEND_CONCAT,&$$,&$1,&$3 CLS_CC); }
+	|	expr '+' expr 	{ do_binary_op(ZEND_ADD,&$$,&$1,&$3 CLS_CC); }
+	|	expr '-' expr 	{ do_binary_op(ZEND_SUB,&$$,&$1,&$3 CLS_CC); }
+	|	expr '*' expr	{ do_binary_op(ZEND_MUL,&$$,&$1,&$3 CLS_CC); }
+	|	expr '/' expr	{ do_binary_op(ZEND_DIV,&$$,&$1,&$3 CLS_CC); }
+	|	expr '%' expr 	{ do_binary_op(ZEND_MOD,&$$,&$1,&$3 CLS_CC); }
+	| 	expr T_SL expr	{ do_binary_op(ZEND_SL, &$$, &$1, &$3 CLS_CC); }
+	|	expr T_SR expr	{ 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); 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); do_binary_op(ZEND_SUB, &$$, &$1, &$2 CLS_CC); }
+	|	'!' expr { do_unary_op(ZEND_BOOL_NOT, &$$, &$2 CLS_CC); }
+	|	'~' expr { do_unary_op(ZEND_BW_NOT, &$$, &$2 CLS_CC); }
+	|	expr T_IS_IDENTICAL expr		{ do_binary_op(ZEND_IS_IDENTICAL, &$$, &$1, &$3 CLS_CC); }
+	|	expr T_IS_NOT_IDENTICAL expr	{ do_binary_op(ZEND_IS_NOT_IDENTICAL, &$$, &$1, &$3 CLS_CC); }
+	|	expr T_IS_EQUAL expr			{ do_binary_op(ZEND_IS_EQUAL, &$$, &$1, &$3 CLS_CC); }
+	|	expr T_IS_NOT_EQUAL expr 		{ do_binary_op(ZEND_IS_NOT_EQUAL, &$$, &$1, &$3 CLS_CC); }
+	|	expr '<' expr 					{ do_binary_op(ZEND_IS_SMALLER, &$$, &$1, &$3 CLS_CC); }
+	|	expr T_IS_SMALLER_OR_EQUAL expr { do_binary_op(ZEND_IS_SMALLER_OR_EQUAL, &$$, &$1, &$3 CLS_CC); }
+	|	expr '>' expr 					{ do_binary_op(ZEND_IS_SMALLER, &$$, &$3, &$1 CLS_CC); }
+	|	expr T_IS_GREATER_OR_EQUAL expr { do_binary_op(ZEND_IS_SMALLER_OR_EQUAL, &$$, &$3, &$1 CLS_CC); }
+	|	'(' expr ')' 	{ $$ = $2; }
+	|	expr '?' { do_begin_qm_op(&$1, &$2 CLS_CC); }
+		expr ':' { do_qm_true(&$4, &$2, &$5 CLS_CC); }
+		expr	 { do_qm_false(&$$, &$7, &$2, &$5 CLS_CC); }
+	|	function_call { $$ = $1; }
+	|	internal_functions_in_yacc { $$ = $1; }
+	|	T_INT_CAST expr 	{ do_cast(&$$, &$2, IS_LONG CLS_CC); }
+	|	T_DOUBLE_CAST expr 	{ do_cast(&$$, &$2, IS_DOUBLE CLS_CC); }
+	|	T_STRING_CAST expr	{ do_cast(&$$, &$2, IS_STRING CLS_CC); } 
+	|	T_ARRAY_CAST expr 	{ do_cast(&$$, &$2, IS_ARRAY CLS_CC); }
+	|	T_OBJECT_CAST expr 	{ do_cast(&$$, &$2, IS_OBJECT CLS_CC); }
+	|	T_BOOL_CAST expr	{ do_cast(&$$, &$2, IS_BOOL CLS_CC); }
+	|	T_UNSET_CAST expr	{ do_cast(&$$, &$2, IS_NULL CLS_CC); }
+	|	T_EXIT exit_expr	{ do_exit(&$$, &$2 CLS_CC); }
+	|	'@' { do_begin_silence(&$1 CLS_CC); } expr { do_end_silence(&$1 CLS_CC); $$ = $3; }
+	|	scalar				{ $$ = $1; }
+	|	T_ARRAY '(' array_pair_list ')' { $$ = $3; }
+	|	'`' encaps_list '`'		{ do_shell_exec(&$$, &$2 CLS_CC); }
+	|	T_PRINT expr  { do_print(&$$, &$2 CLS_CC); }
+;
+
+function_call:
+		T_STRING	'(' { $2.u.opline_num = do_begin_function_call(&$1 CLS_CC); }
+				function_call_parameter_list
+				')' { do_end_function_call(&$1, &$$, &$4, 0, $2.u.opline_num CLS_CC); do_extended_fcall_end(CLS_C); }
+	|	cvar '(' { do_begin_dynamic_function_call(&$1 CLS_CC); } 
+				function_call_parameter_list 
+				')' { do_end_function_call(&$1, &$$, &$4, 0, 1 CLS_CC); do_extended_fcall_end(CLS_C);}
+	|	T_STRING T_PAAMAYIM_NEKUDOTAYIM T_STRING '(' { do_extended_fcall_begin(CLS_C); do_begin_class_member_function_call(&$1, &$3 CLS_CC); } 
+											function_call_parameter_list 
+											')' { do_end_function_call(&$3, &$$, &$6, 1, 1 CLS_CC); 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 		{ 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 				{ 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; 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	{ do_add_static_array_element(&$$, &$3, &$5); }
+	|	non_empty_static_array_pair_list ',' static_scalar { 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); do_add_static_array_element(&$$, &$1, &$3); }
+	|	static_scalar { $$.op_type = IS_CONST; INIT_PZVAL(&$$.u.constant); array_init(&$$.u.constant); 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 { do_end_variable_parse(BP_VAR_R, 0 CLS_CC); $$ = $1; }
+;
+
+
+w_cvar:
+	cvar { do_end_variable_parse(BP_VAR_W, 0 CLS_CC); $$ = $1; }
+;
+
+
+rw_cvar:
+	cvar { do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); $$ = $1; }
+;
+
+
+cvar:
+		cvar_without_objects { $$ = $1; }
+	|	cvar_without_objects T_OBJECT_OPERATOR { do_push_object(&$1 CLS_CC); } ref_list { $$ = $4; }
+;
+
+
+cvar_without_objects:
+		reference_variable { $$ = $1; }
+	|	simple_indirect_reference reference_variable { 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			{ do_fetch_globals(&$1 CLS_CC); 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 { do_push_object(&$1 CLS_CC); } object_property { $$ = $4; }
+;
+
+object_property:
+		object_dim_list { $$ = $1; }
+	|	cvar_without_objects { do_end_variable_parse(BP_VAR_R, 0 CLS_CC); } { znode tmp_znode;  do_pop_object(&tmp_znode CLS_CC);  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;  do_pop_object(&tmp_znode CLS_CC);  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								{ do_add_list_element(&$1 CLS_CC); }
+	|	T_LIST '(' { do_new_list_begin(CLS_C); } assignment_list ')'	{ do_new_list_end(CLS_C); }
+	|	/* empty */							{ do_add_list_element(NULL CLS_CC); }
+;
+
+
+array_pair_list:
+		/* empty */ { 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	{ do_add_array_element(&$$, &$5, &$3, 0 CLS_CC); }
+	|	non_empty_array_pair_list ',' expr			{ do_add_array_element(&$$, &$3, NULL, 0 CLS_CC); }
+	|	expr T_DOUBLE_ARROW expr	{ do_init_array(&$$, &$3, &$1, 0 CLS_CC); }
+	|	expr 				{ do_init_array(&$$, &$1, NULL, 0 CLS_CC); }
+	|	non_empty_array_pair_list ',' expr T_DOUBLE_ARROW '&' w_cvar { do_add_array_element(&$$, &$6, &$3, 1 CLS_CC); }
+	|	non_empty_array_pair_list ',' '&' w_cvar { do_add_array_element(&$$, &$4, NULL, 1 CLS_CC); }
+	|	expr T_DOUBLE_ARROW '&' w_cvar	{ do_init_array(&$$, &$4, &$1, 1 CLS_CC); }
+	|	'&' w_cvar 			{ do_init_array(&$$, &$2, NULL, 1 CLS_CC); }
+;
+
+encaps_list:
+		encaps_list encaps_var { do_end_variable_parse(BP_VAR_R, 0 CLS_CC);  do_add_variable(&$$, &$1, &$2 CLS_CC); }
+	|	encaps_list T_STRING			{ do_add_string(&$$, &$1, &$2 CLS_CC); }
+	|	encaps_list T_NUM_STRING		{ do_add_string(&$$, &$1, &$2 CLS_CC); }
+	|	encaps_list T_ENCAPSED_AND_WHITESPACE	{ do_add_string(&$$, &$1, &$2 CLS_CC); }
+	|	encaps_list T_CHARACTER 		{ do_add_char(&$$, &$1, &$2 CLS_CC); }
+	|	encaps_list T_BAD_CHARACTER		{ do_add_string(&$$, &$1, &$2 CLS_CC); }
+	|	encaps_list '['		{ $2.u.constant.value.lval = (long) '['; do_add_char(&$$, &$1, &$2 CLS_CC); }
+	|	encaps_list ']'		{ $2.u.constant.value.lval = (long) ']'; do_add_char(&$$, &$1, &$2 CLS_CC); }
+	|	encaps_list '{'		{ $2.u.constant.value.lval = (long) '{'; do_add_char(&$$, &$1, &$2 CLS_CC); }
+	|	encaps_list '}'		{ $2.u.constant.value.lval = (long) '}'; do_add_char(&$$, &$1, &$2 CLS_CC); }
+	|	encaps_list T_OBJECT_OPERATOR  { znode tmp;  $2.u.constant.value.lval = (long) '-';  do_add_char(&tmp, &$1, &$2 CLS_CC);  $2.u.constant.value.lval = (long) '>'; do_add_char(&$$, &tmp, &$2 CLS_CC); }
+	|	/* empty */			{ do_init_string(&$$ CLS_CC); }
+
+;
+
+
+
+encaps_var:
+		T_VARIABLE { do_fetch_globals(&$1 CLS_CC); do_begin_variable_parse(CLS_C); fetch_simple_variable(&$$, &$1, 1 CLS_CC); }
+	|	T_VARIABLE '[' { do_begin_variable_parse(CLS_C); } encaps_var_offset ']'	{ do_fetch_globals(&$1 CLS_CC);  fetch_array_begin(&$$, &$1, &$4 CLS_CC); }
+	|	T_VARIABLE T_OBJECT_OPERATOR T_STRING { do_begin_variable_parse(CLS_C); fetch_simple_variable(&$2, &$1, 1 CLS_CC); do_fetch_property(&$$, &$2, &$3 CLS_CC); }
+	|	T_DOLLAR_OPEN_CURLY_BRACES expr '}' { do_begin_variable_parse(CLS_C);  fetch_simple_variable(&$$, &$2, 1 CLS_CC); }
+	|	T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '[' expr ']' '}' { 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 ')'	{ do_isset_or_isempty(ZEND_ISSET, &$$, &$3 CLS_CC); }
+	|	T_EMPTY '(' cvar ')'	{ do_isset_or_isempty(ZEND_ISEMPTY, &$$, &$3 CLS_CC); }
+	|	T_INCLUDE expr 			{ do_include_or_eval(ZEND_INCLUDE, &$$, &$2 CLS_CC); }
+	|	T_INCLUDE_ONCE expr 	{ do_include_or_eval(ZEND_INCLUDE_ONCE, &$$, &$2 CLS_CC); }
+	|	T_EVAL '(' expr ')' 	{ do_include_or_eval(ZEND_EVAL, &$$, &$3 CLS_CC); }
+	|	T_REQUIRE expr			{ do_include_or_eval(ZEND_REQUIRE, &$$, &$2 CLS_CC); }
+	|	T_REQUIRE_ONCE expr		{ do_include_or_eval(ZEND_REQUIRE_ONCE, &$$, &$2 CLS_CC); }
+;
+
+
+%%
+

Zend/zend-scanner.h

@@ -2,12 +2,12 @@
    +----------------------------------------------------------------------+
    | Zend Engine                                                          |
    +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2004 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
    +----------------------------------------------------------------------+
-   | This source file is subject to version 2.00 of the Zend license,     |
+   | 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 through the world-wide-web at the following url:           |
-   | http://www.zend.com/license/2_00.txt.                                |
+   | 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.              |
@@ -17,51 +17,40 @@
    +----------------------------------------------------------------------+
 */
 
-/* $Id$ */
 
 #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;
-	zend_file_handle *in;
+	FILE *in;
+#else
+	ZendFlexLexer *ZFL;
+	istream *input_file;
+#endif
 	uint lineno;
 	char *filename;
-
-#ifdef ZEND_MULTIBYTE
-	/* original (unfiltered) script */
-	char *script_org;
-	int script_org_size;
-
-	/* filtered script */
-	char *script_filtered;
-	int script_filtered_size;
-
-	/* input/ouput filters */
-	zend_encoding_filter input_filter;
-	zend_encoding_filter output_filter;
-	zend_encoding *script_encoding;
-	zend_encoding *internal_encoding;
-#endif /* ZEND_MULTIBYTE */
 } 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);
-ZEND_API void zend_save_lexical_state(zend_lex_state *lex_state TSRMLS_DC);
-ZEND_API void zend_restore_lexical_state(zend_lex_state *lex_state TSRMLS_DC);
-ZEND_API int zend_prepare_string_for_scanning(zval *str, char *filename TSRMLS_DC);
-
 END_EXTERN_C()
 
 #endif
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * indent-tabs-mode: t
- * End:
- */

Zend/zend.h

@@ -2,12 +2,12 @@
    +----------------------------------------------------------------------+
    | Zend Engine                                                          |
    +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2004 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
    +----------------------------------------------------------------------+
-   | This source file is subject to version 2.00 of the Zend license,     |
+   | 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 through the world-wide-web at the following url:           |
-   | http://www.zend.com/license/2_00.txt.                                |
+   | 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.              |
@@ -17,14 +17,11 @@
    +----------------------------------------------------------------------+
 */
 
-/* $Id$ */
 
 #ifndef ZEND_H
 #define ZEND_H
 
-#define ZEND_VERSION "2.0.1-dev"
-
-#define ZEND_ENGINE_2
+#define ZEND_VERSION "1.0.3"
 
 #ifdef __cplusplus
 #define BEGIN_EXTERN_C() extern "C" {
@@ -42,28 +39,8 @@
 
 #ifdef ZEND_WIN32
 # include "zend_config.w32.h"
-# define ZEND_PATHS_SEPARATOR		';'
-#elif defined(NETWARE)
-# include "zend_config.nw.h"
-# include "acconfig.h"
-#elif defined(__riscos__)
-# include "zend_config.h"
-# define ZEND_PATHS_SEPARATOR		';'
 #else
 # include "zend_config.h"
-# define ZEND_PATHS_SEPARATOR		':'
-#endif
-
-
-#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
 
 /* all HAVE_XXX test have to be after the include of zend_config above */
@@ -80,18 +57,7 @@
 # include <dlfcn.h>
 #endif
 
-#if HAVE_MACH_O_DYLD_H
-#include <mach-o/dyld.h>
-
-/* MH_BUNDLE loading functions for Mac OS X / Darwin */
-void *zend_mh_bundle_load (char* bundle_path);
-int zend_mh_bundle_unload (void *bundle_handle);
-void *zend_mh_bundle_symbol(void *bundle_handle, const char *symbol_name);
-const char *zend_mh_bundle_error(void);
-
-#endif /* HAVE_MACH_O_DYLD_H */
-
-#if defined(HAVE_LIBDL) && !defined(HAVE_MACH_O_DYLD_H)
+#if defined(HAVE_LIBDL)
 
 # ifndef RTLD_LAZY
 #  define RTLD_LAZY 1    /* Solaris 1, FreeBSD's (2.1.7.1 and older) */
@@ -101,25 +67,9 @@ const char *zend_mh_bundle_error(void);
 #  define RTLD_GLOBAL 0
 # endif
 
-# if defined(RTLD_GROUP) && defined(RTLD_WORLD) && defined(RTLD_PARENT)
-#  define DL_LOAD(libname)			dlopen(libname, RTLD_LAZY | RTLD_GLOBAL | RTLD_GROUP | RTLD_WORLD | RTLD_PARENT)
-# else
-#  define DL_LOAD(libname)			dlopen(libname, RTLD_LAZY | RTLD_GLOBAL)
-# endif
+# define DL_LOAD(libname)			dlopen(libname, RTLD_LAZY | RTLD_GLOBAL)
 # define DL_UNLOAD					dlclose
-# if defined(DLSYM_NEEDS_UNDERSCORE)
-#  define DL_FETCH_SYMBOL(h,s)		dlsym((h), "_" s)
-# else
-#  define DL_FETCH_SYMBOL			dlsym
-# endif
-# define DL_ERROR					dlerror
-# define DL_HANDLE					void *
-# define ZEND_EXTENSIONS_SUPPORT	1
-#elif defined(HAVE_MACH_O_DYLD_H)
-# define DL_LOAD(libname)			zend_mh_bundle_load(libname)
-# define DL_UNLOAD(handle)			zend_mh_bundle_unload(handle)
-# define DL_FETCH_SYMBOL(h,s)		zend_mh_bundle_symbol(h,s)
-# define DL_ERROR					zend_mh_bundle_error
+# define DL_FETCH_SYMBOL			dlsym
 # define DL_HANDLE					void *
 # define ZEND_EXTENSIONS_SUPPORT	1
 #elif defined(ZEND_WIN32)
@@ -133,50 +83,11 @@ const char *zend_mh_bundle_error(void);
 # define ZEND_EXTENSIONS_SUPPORT	0
 #endif
 
-#if HAVE_ALLOCA_H && !defined(_ALLOCA_H)
-#  include <alloca.h>
+#if HAVE_ALLOCA_H
+# include <alloca.h>
 #endif
 
-/* AIX requires this to be the first thing in the file.  */
-#ifndef __GNUC__
-# ifndef HAVE_ALLOCA_H
-#  ifdef _AIX
-#pragma alloca
-#  else
-#   ifndef alloca /* predefined by HP cc +Olibcalls */
-char *alloca ();
-#   endif
-#  endif
-# endif
-#endif
-
-/* GCC x.y.z supplies __GNUC__ = x and __GNUC_MINOR__ = y */
-#ifdef __GNUC__
-# define ZEND_GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__)
-#else
-# define ZEND_GCC_VERSION 0
-#endif
-
-#if ZEND_GCC_VERSION >= 2096
-# define ZEND_ATTRIBUTE_MALLOC __attribute__ ((__malloc__))
-#else
-# define ZEND_ATTRIBUTE_MALLOC
-#endif
-
-#if ZEND_GCC_VERSION >= 2007
-# define ZEND_ATTRIBUTE_FORMAT(type, idx, first) __attribute__ ((format(type, idx, first)))
-#else
-# define ZEND_ATTRIBUTE_FORMAT(type, idx, first)
-#endif
-
-#if ZEND_GCC_VERSION >= 3001
-# define ZEND_ATTRIBUTE_PTR_FORMAT(type, idx, first) __attribute__ ((format(type, idx, first)))
-#else
-# define ZEND_ATTRIBUTE_PTR_FORMAT(type, idx, first)
-#endif
-
-
-#if (HAVE_ALLOCA || (defined (__GNUC__) && __GNUC__ >= 2)) && !(defined(ZTS) && defined(ZEND_WIN32)) && !(defined(ZTS) && defined(NETWARE)) && !(defined(ZTS) && defined(HPUX)) && !defined(__darwin__) && !defined(__APPLE__)
+#if (HAVE_ALLOCA || (defined (__GNUC__) && __GNUC__ >= 2)) && !(defined(ZTS) && defined(ZEND_WIN32))
 # define do_alloca(p) alloca(p)
 # define free_alloca(p)
 #else
@@ -221,19 +132,11 @@ char *alloca ();
 #include "zend_errors.h"
 #include "zend_alloc.h"
 
-#include "zend_types.h"
-
-#ifdef HAVE_LIMITS_H
-# include <limits.h>
-#endif
-
-#ifndef LONG_MAX
-#define LONG_MAX 2147483647L
-#endif
-
-#ifndef LONG_MIN
-#define LONG_MIN (- LONG_MAX - 1)
-#endif
+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
@@ -242,12 +145,10 @@ char *alloca ();
 
 
 #include "zend_hash.h"
-#include "zend_ts_hash.h"
 #include "zend_llist.h"
 
-#define INTERNAL_FUNCTION_PARAMETERS int ht, zval *return_value, zval *this_ptr, int return_value_used TSRMLS_DC
-#define INTERNAL_FUNCTION_PARAM_PASSTHRU ht, return_value, this_ptr, return_value_used TSRMLS_CC
-
+#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
@@ -255,23 +156,6 @@ char *alloca ();
 typedef struct _zval_struct zval;
 typedef struct _zend_class_entry zend_class_entry;
 
-typedef struct _zend_object {
-	zend_class_entry *ce;
-	HashTable *properties;
-	unsigned int in_get:1;
-	unsigned int in_set:1;
-} zend_object;
-
-typedef unsigned int zend_object_handle;
-typedef	struct _zend_object_value zend_object_value;
-
-#include "zend_object_handlers.h"
-
-struct _zend_object_value {
-	zend_object_handle handle;
-	zend_object_handlers *handlers;
-};
-
 typedef union _zvalue_value {
 	long lval;					/* long value */
 	double dval;				/* double value */
@@ -280,91 +164,82 @@ typedef union _zvalue_value {
 		int len;
 	} str;
 	HashTable *ht;				/* hash table value */
-	zend_object_value obj;
+	struct {
+		zend_class_entry *ce;
+		HashTable *properties;
+	} obj;
 } zvalue_value;
 
 
 struct _zval_struct {
 	/* Variable information */
 	zvalue_value value;		/* value */
-	zend_uint refcount;
 	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
 
-/* A lot of stuff needs shifiting around in order to include zend_compile.h here */
-union _zend_function;
-
-#include "zend_iterators.h"
-
 struct _zend_class_entry {
 	char type;
 	char *name;
-	zend_uint name_length;
+	uint name_length;
 	struct _zend_class_entry *parent; 
-	int refcount;
+	int *refcount;
 	zend_bool constants_updated;
-	zend_uint ce_flags;
 
 	HashTable function_table;
 	HashTable default_properties;
-	HashTable properties_info;
-	HashTable *static_members;
-	HashTable constants_table;
-	struct _zend_function_entry *builtin_functions;
-
-	union _zend_function *constructor;
-	union _zend_function *destructor;
-	union _zend_function *clone;
-	union _zend_function *__get;
-	union _zend_function *__set;
-	union _zend_function *__call;
-
-	zend_class_iterator_funcs iterator_funcs;
+	zend_function_entry *builtin_functions;
 
 	/* handlers */
-	zend_object_value (*create_object)(zend_class_entry *class_type TSRMLS_DC);
-	zend_object_iterator *(*get_iterator)(zend_class_entry *ce, zval *object TSRMLS_DC);
-	int (*interface_gets_implemented)(zend_class_entry *iface, zend_class_entry *class_type TSRMLS_DC); /* a class implements this interface */
-
-	zend_class_entry **interfaces;
-	zend_uint num_interfaces;
-
-	char *filename;
-	zend_uint line_start;
-	zend_uint line_end;
-	char *doc_comment;
-	zend_uint doc_comment_len;
-	
-	struct _zend_module_entry *module;
+	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);
 };
 
-#include "zend_stream.h"
+
+
 typedef struct _zend_utility_functions {
-	void (*error_function)(int type, const char *error_filename, const uint error_lineno, const char *format, va_list args) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 4, 0);
-	int (*printf_function)(const char *format, ...) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 1, 2);
+	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_configuration_directive)(char *name, uint name_length, zval *contents);
+	int (*get_ini_entry)(char *name, uint name_length, zval *contents);
 	void (*ticks_function)(int ticks);
-	void (*on_timeout)(int seconds TSRMLS_DC);
-	int (*stream_open_function)(const char *filename, zend_file_handle *handle TSRMLS_DC);
-	int (*vspprintf_function)(char **pbuf, size_t max_len, const char *format, va_list ap);
-	char *(*getenv_function)(char *name, size_t name_len TSRMLS_DC);
 } zend_utility_functions;
 
 		
 typedef struct _zend_utility_values {
 	char *import_use_extension;
 	uint import_use_extension_length;
-	zend_bool html_errors;
 } zend_utility_values;
 
 
@@ -373,15 +248,12 @@ 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 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)-1)
+#define ZEND_STRS(str)		(str), (sizeof(str)
 #define ZEND_NORMALIZE_BOOL(n)			\
 	((n) ? (((n)>0) ? 1 : -1) : 0)
-#define ZEND_TRUTH(x)		((x) ? 1 : 0)
-#define ZEND_LOG_XOR(a, b)		(ZEND_TRUTH(a) ^ ZEND_TRUTH(b))
-
 
 
 /* data types */
@@ -396,9 +268,8 @@ typedef int (*zend_write_func_t)(const char *str, uint str_length);
 #define IS_CONSTANT	8
 #define IS_CONSTANT_ARRAY	9
 
-/* Ugly hack to support constants as static array indices */
-#define IS_CONSTANT_INDEX	0x80
-
+/* 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)
@@ -406,75 +277,46 @@ typedef int (*zend_write_func_t)(const char *str, uint str_length);
 #define OE_IS_METHOD	(1<<2)
 
 
-int zend_startup(zend_utility_functions *utility_functions, char **extensions, int start_builtin_functions);
-void zend_shutdown(TSRMLS_D);
-void zend_register_standard_ini_entries(TSRMLS_D);
+/* Argument passing types */
+#define BYREF_NONE 0
+#define BYREF_FORCE 1
+#define BYREF_ALLOW 2
+#define BYREF_FORCE_REST 3
 
-#ifdef ZTS
-void zend_post_startup(TSRMLS_D);
-#endif
+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(char *filename, uint lineno);
+ZEND_API void zend_bailout(void);
 END_EXTERN_C()
-
-#define zend_bailout()		_zend_bailout(__FILE__, __LINE__)
-
-#define zend_try												\
-	{															\
-		jmp_buf orig_bailout;									\
-		zend_bool orig_bailout_set=EG(bailout_set);				\
-																\
-		EG(bailout_set) = 1;									\
-		memcpy(&orig_bailout, &EG(bailout), sizeof(jmp_buf));	\
-		if (setjmp(EG(bailout))==0)
-#define zend_catch												\
-		else
-#define zend_end_try()											\
-		memcpy(&EG(bailout), &orig_bailout, sizeof(jmp_buf));	\
-		EG(bailout_set) = orig_bailout_set;						\
-	}
-#define zend_first_try		EG(bailout_set)=0;	zend_try
-
-BEGIN_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 TSRMLS_DC);
-ZEND_API void zend_print_flat_zval_r(zval *expr TSRMLS_DC);
-ZEND_API void zend_print_zval_r_ex(zend_write_func_t write_func, zval *expr, int indent TSRMLS_DC);
-ZEND_API void zend_output_debug_string(zend_bool trigger_break, char *format, ...) ZEND_ATTRIBUTE_FORMAT(printf, 2, 3);
-END_EXTERN_C()
-
-void zend_activate(TSRMLS_D);
-void zend_deactivate(TSRMLS_D);
-void zend_call_destructors(TSRMLS_D);
-void zend_activate_modules(TSRMLS_D);
-void zend_deactivate_modules(TSRMLS_D);
-void zend_post_deactivate_modules(TSRMLS_D);
+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
 
-BEGIN_EXTERN_C()
-ZEND_API void free_estring(char **str_p);
-END_EXTERN_C()
+ZEND_API extern char *empty_string;
 
-/* FIXME: Check if we can save if (ptr) too */
+#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_FREE(ptr) if (ptr) { efree(ptr); }
-#define STR_FREE_REL(ptr) if (ptr) { efree_rel(ptr); }
-
-#define STR_EMPTY_ALLOC() estrndup("", sizeof("")-1)
-
-#define STR_REALLOC(ptr, size) \
-			ptr = (char *) erealloc(ptr, size);
+#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))
@@ -483,27 +325,21 @@ END_EXTERN_C()
 
 
 BEGIN_EXTERN_C()
-extern ZEND_API int (*zend_printf)(const char *format, ...) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 1, 2);
+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_ATTRIBUTE_PTR_FORMAT(printf, 4, 0);
-extern void (*zend_on_timeout)(int seconds TSRMLS_DC);
-extern ZEND_API int (*zend_stream_open_function)(const char *filename, zend_file_handle *handle TSRMLS_DC);
-extern int (*zend_vspprintf)(char **pbuf, size_t max_len, const char *format, va_list ap);
-extern ZEND_API char *(*zend_getenv)(char *name, size_t name_len TSRMLS_DC);
+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, ...) ZEND_ATTRIBUTE_FORMAT(printf, 2, 3);
+ZEND_API void zend_error(int type, const char *format, ...);
 
 void zenderror(char *error);
 
-/* The following #define is used for code duality in PHP for Engine 1 & 2 */
-#define ZEND_STANDARD_CLASS_DEF_PTR zend_standard_class_def
-extern ZEND_API zend_class_entry *zend_standard_class_def;
-extern ZEND_API zend_utility_values zend_uv;
+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()
@@ -516,10 +352,10 @@ END_EXTERN_C()
 
 BEGIN_EXTERN_C()
 ZEND_API void zend_message_dispatcher(long message, void *data);
-
-ZEND_API int zend_get_configuration_directive(char *name, uint name_length, zval *contents);
 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
@@ -528,7 +364,6 @@ END_EXTERN_C()
 #define ZMSG_MEMORY_LEAK_DETECTED		4L
 #define ZMSG_MEMORY_LEAK_REPEATED		5L
 #define ZMSG_LOG_SCRIPT_NAME			6L
-#define ZMSG_MEMORY_LEAKS_GRAND_TOTAL	7L
 
 
 #define ZVAL_ADDREF(pz)		(++(pz)->refcount)
@@ -586,23 +421,18 @@ END_EXTERN_C()
 	}										\
 	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	4
+#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 */
 
@@ -610,6 +440,5 @@ END_EXTERN_C()
  * Local variables:
  * tab-width: 4
  * c-basic-offset: 4
- * indent-tabs-mode: t
  * End:
  */

Zend/zend_API.h

@@ -2,91 +2,58 @@
    +----------------------------------------------------------------------+
    | Zend Engine                                                          |
    +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2004 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
    +----------------------------------------------------------------------+
-   | This source file is subject to version 2.00 of the Zend license,     |
+   | 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 through the world-wide-web at the following url:           |
-   | http://www.zend.com/license/2_00.txt.                                |
+   | 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>                                |
-   |          Andrei Zmievski <andrei@php.net>                            |
    +----------------------------------------------------------------------+
 */
 
-/* $Id$ */
 
 #ifndef ZEND_API_H
 #define ZEND_API_H
 
-#include "zend_modules.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))
 
-BEGIN_EXTERN_C()
+#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)
 
-typedef struct _zend_function_entry {
-	char *fname;
-	void (*handler)(INTERNAL_FUNCTION_PARAMETERS);
-	struct _zend_arg_info *arg_info;
-	zend_uint num_args;
-	zend_uint flags;
-} zend_function_entry;
+#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_FN(name) zif_##name
-#define ZEND_NAMED_FUNCTION(name)		void name(INTERNAL_FUNCTION_PARAMETERS)
-#define ZEND_FUNCTION(name)				ZEND_NAMED_FUNCTION(ZEND_FN(name))
-#define ZEND_METHOD(classname, name)	ZEND_NAMED_FUNCTION(ZEND_FN(classname##_##name))
-
-#define ZEND_FENTRY(zend_name, name, arg_info, flags)	{ #zend_name, name, arg_info, (zend_uint) (sizeof(arg_info)/sizeof(struct _zend_arg_info)-1), flags },
-
-#define ZEND_NAMED_FE(zend_name, name, arg_info)	ZEND_FENTRY(zend_name, name, arg_info, 0)
-#define ZEND_FE(name, arg_info)						ZEND_FENTRY(name, ZEND_FN(name), arg_info, 0)
-#define ZEND_FALIAS(name, alias, arg_info)			ZEND_FENTRY(name, ZEND_FN(alias), arg_info, 0)
-#define ZEND_ME(classname, name, arg_info, flags)	ZEND_FENTRY(name, ZEND_FN(classname##_##name), arg_info, flags)
-#define ZEND_ABSTRACT_ME(classname, name, arg_info)	ZEND_FENTRY(name, NULL, arg_info, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-#define ZEND_MALIAS(classname, name, alias, arg_info, flags) \
-                                                    ZEND_FENTRY(name, ZEND_FN(classname##_##alias), arg_info, flags)
-#define ZEND_ME_MAPPING(name, func_name, arg_types) ZEND_NAMED_FE(name, ZEND_FN(func_name), arg_types)
-
-#define ZEND_ARG_INFO(pass_by_ref, name)							{ #name, sizeof(#name)-1, NULL, 0, 0, pass_by_ref, 0, 0 },
-#define ZEND_ARG_PASS_INFO(pass_by_ref)								{ NULL, 0, NULL, 0, 0, pass_by_ref, 0, 0 },
-#define ZEND_ARG_OBJ_INFO(pass_by_ref, name, classname, allow_null) { #name, sizeof(#name)-1, #classname, sizeof(#classname)-1, allow_null, pass_by_ref, 0, 0 },
-#define ZEND_BEGIN_ARG_INFO_EX(name, pass_rest_by_reference, return_reference, required_num_args)	\
-	zend_arg_info name[] = {																		\
-		{ NULL, 0, NULL, 0, 0, pass_rest_by_reference, return_reference, required_num_args },
-#define ZEND_BEGIN_ARG_INFO(name, pass_rest_by_reference)	\
-	ZEND_BEGIN_ARG_INFO_EX(name, pass_rest_by_reference, ZEND_RETURN_REFERENCE_AGNOSTIC, -1)
-#define ZEND_END_ARG_INFO()		};
-
-/* Name macros */
-#define ZEND_MODULE_STARTUP_N(module)       zm_startup_##module
-#define ZEND_MODULE_SHUTDOWN_N(module)		zm_shutdown_##module
-#define ZEND_MODULE_ACTIVATE_N(module)		zm_activate_##module
-#define ZEND_MODULE_DEACTIVATE_N(module)	zm_deactivate_##module
-#define ZEND_MODULE_POST_ZEND_DEACTIVATE_N(module)	zm_post_zend_deactivate_##module
-#define ZEND_MODULE_INFO_N(module)			zm_info_##module
-
-/* Declaration macros */
-#define ZEND_MODULE_STARTUP_D(module)		int ZEND_MODULE_STARTUP_N(module)(INIT_FUNC_ARGS)
-#define ZEND_MODULE_SHUTDOWN_D(module)		int ZEND_MODULE_SHUTDOWN_N(module)(SHUTDOWN_FUNC_ARGS)
-#define ZEND_MODULE_ACTIVATE_D(module)		int ZEND_MODULE_ACTIVATE_N(module)(INIT_FUNC_ARGS)
-#define ZEND_MODULE_DEACTIVATE_D(module)	int ZEND_MODULE_DEACTIVATE_N(module)(SHUTDOWN_FUNC_ARGS)
-#define ZEND_MODULE_POST_ZEND_DEACTIVATE_D(module)	int ZEND_MODULE_POST_ZEND_DEACTIVATE_N(module)(void)
-#define ZEND_MODULE_INFO_D(module)			void ZEND_MODULE_INFO_N(module)(ZEND_MODULE_INFO_FUNC_ARGS)
+#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) \
-    BEGIN_EXTERN_C()\
-	ZEND_DLEXPORT zend_module_entry *get_module(void) { return &name##_module_entry; }\
-    END_EXTERN_C()
+	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 {
@@ -96,18 +63,14 @@ typedef struct _zend_function_entry {
 #ifdef ZTS
 
 #define ZEND_DECLARE_MODULE_GLOBALS(module_name)							\
-	ts_rsrc_id module_name##_globals_id;
-#define ZEND_EXTERN_MODULE_GLOBALS(module_name)								\
-	extern ts_rsrc_id module_name##_globals_id;
+	static ts_rsrc_id module_name##_globals_id;
 #define ZEND_INIT_MODULE_GLOBALS(module_name, globals_ctor, globals_dtor)	\
-	ts_allocate_id(&module_name##_globals_id, sizeof(zend_##module_name##_globals), (ts_allocate_ctor) globals_ctor, (ts_allocate_dtor) 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)							\
-	zend_##module_name##_globals module_name##_globals;
-#define ZEND_EXTERN_MODULE_GLOBALS(module_name)								\
-	extern zend_##module_name##_globals module_name##_globals;
+	static zend_##module_name##_globals module_name##_globals;
 #define ZEND_INIT_MODULE_GLOBALS(module_name, globals_ctor, globals_dtor)	\
 	globals_ctor(&module_name##_globals);
 
@@ -115,86 +78,48 @@ typedef struct _zend_function_entry {
 
 
 
-#define INIT_CLASS_ENTRY(class_container, class_name, functions) INIT_OVERLOADED_CLASS_ENTRY(class_container, class_name, functions, NULL, NULL, NULL)
+#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.name_length = sizeof(class_name)-1;		\
 		class_container.builtin_functions = functions;			\
-		class_container.constructor = NULL;						\
-		class_container.destructor = NULL;						\
-		class_container.clone = NULL;							\
-		class_container.create_object = NULL;	 				\
-		class_container.interface_gets_implemented = NULL;		\
-		class_container.__call = handle_fcall;	\
-		class_container.__get = handle_propget;	\
-		class_container.__set = handle_propset;	\
-		class_container.parent = NULL;          \
-		class_container.num_interfaces = 0;     \
-		class_container.interfaces = NULL;      \
-		class_container.get_iterator = NULL;    \
-		class_container.iterator_funcs.funcs = NULL;  \
-		class_container.module = NULL;          \
+		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);
 
-BEGIN_EXTERN_C()
 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 TSRMLS_DC);
+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 TSRMLS_DC);
+ZEND_API int zend_get_parameters_array_ex(int param_count, zval ***argument_array);
 
-#define zend_get_parameters_array(ht, param_count, argument_array)			\
-	_zend_get_parameters_array(ht, param_count, argument_array TSRMLS_CC)
-#define zend_get_parameters_array_ex(param_count, argument_array)			\
-	_zend_get_parameters_array_ex(param_count, argument_array TSRMLS_CC)
+ZEND_API int ParameterPassedByReference(int ht, uint n);
 
-
-/* Parameter parsing API -- andrei */
-
-#define ZEND_PARSE_PARAMS_QUIET 1<<1
-ZEND_API int zend_parse_parameters(int num_args TSRMLS_DC, char *type_spec, ...);
-ZEND_API int zend_parse_parameters_ex(int flags, int num_args TSRMLS_DC, char *type_spec, ...);
-ZEND_API char *zend_zval_type_name(zval *arg);
-
-ZEND_API int zend_parse_method_parameters(int num_args TSRMLS_DC, zval *this_ptr, char *type_spec, ...);
-ZEND_API int zend_parse_method_parameters_ex(int flags, int num_args TSRMLS_DC, zval *this_ptr, char *type_spec, ...);
-
-/* End of parameter parsing API -- andrei */
-
-ZEND_API int zend_register_functions(zend_class_entry *scope, zend_function_entry *functions, HashTable *function_table, int type TSRMLS_DC);
-ZEND_API void zend_unregister_functions(zend_function_entry *functions, int count, HashTable *function_table TSRMLS_DC);
+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 int zend_register_module_ex(zend_module_entry *module TSRMLS_DC);
 
-ZEND_API zend_class_entry *zend_register_internal_class(zend_class_entry *class_entry TSRMLS_DC);
-ZEND_API zend_class_entry *zend_register_internal_class_ex(zend_class_entry *class_entry, zend_class_entry *parent_ce, char *parent_name TSRMLS_DC);
-ZEND_API zend_class_entry *zend_register_internal_interface(zend_class_entry *orig_class_entry TSRMLS_DC);
-ZEND_API void zend_class_implements(zend_class_entry *class_entry TSRMLS_DC, int num_interfaces, ...);
+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 int zend_disable_function(char *function_name, uint function_name_length TSRMLS_DC);
-ZEND_API int zend_disable_class(char *class_name, uint class_name_length TSRMLS_DC);
+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 zend_wrong_param_count(TSRMLS_D);
-ZEND_API zend_bool zend_is_callable(zval *callable, zend_bool syntax_only, char **callable_name);
-ZEND_API zend_bool zend_make_callable(zval *callable, char **callable_name TSRMLS_DC);
-ZEND_API char *zend_get_module_version(char *module_name);
-ZEND_API int zend_get_module_started(char *module_name);
-ZEND_API int zend_declare_property(zend_class_entry *ce, char *name, int name_length, zval *property, int access_type TSRMLS_DC);
-ZEND_API int zend_declare_property_null(zend_class_entry *ce, char *name, int name_length, int access_type TSRMLS_DC);
-ZEND_API int zend_declare_property_long(zend_class_entry *ce, char *name, int name_length, long value, int access_type TSRMLS_DC);
-ZEND_API int zend_declare_property_string(zend_class_entry *ce, char *name, int name_length, char *value, int access_type TSRMLS_DC);
-
-ZEND_API void zend_update_property(zend_class_entry *scope, zval *object, char *name, int name_length, zval *value TSRMLS_DC);
-ZEND_API void zend_update_property_null(zend_class_entry *scope, zval *object, char *name, int name_length TSRMLS_DC);
-ZEND_API void zend_update_property_long(zend_class_entry *scope, zval *object, char *name, int name_length, long value TSRMLS_DC);
-ZEND_API void zend_update_property_string(zend_class_entry *scope, zval *object, char *name, int name_length, char *value TSRMLS_DC);
-
-ZEND_API zval *zend_read_property(zend_class_entry *scope, zval *object, char *name, int name_length, zend_bool silent TSRMLS_DC);
-
-ZEND_API zend_class_entry *zend_get_class_entry(zval *zobject TSRMLS_DC);
+ZEND_API void wrong_param_count(void);
 
 #define getThis() (this_ptr)
 
@@ -202,8 +127,8 @@ ZEND_API zend_class_entry *zend_get_class_entry(zval *zobject TSRMLS_DC);
 #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()					{ zend_wrong_param_count(TSRMLS_C); return; }
-#define ZEND_WRONG_PARAM_COUNT_WITH_RETVAL(ret)		{ zend_wrong_param_count(TSRMLS_C); return ret; }
+#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
@@ -212,260 +137,239 @@ ZEND_API zend_class_entry *zend_get_class_entry(zval *zobject TSRMLS_DC);
 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 TSRMLS_CC)
-#define object_init_ex(arg, ce)	_object_init_ex((arg), (ce) ZEND_FILE_LINE_CC TSRMLS_CC)
-#define object_and_properties_init(arg, ce, properties)	_object_and_properties_init((arg), (ce), (properties) ZEND_FILE_LINE_CC TSRMLS_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 TSRMLS_DC);
-ZEND_API int _object_init_ex(zval *arg, zend_class_entry *ce ZEND_FILE_LINE_DC TSRMLS_DC);
-ZEND_API int _object_and_properties_init(zval *arg, zend_class_entry *ce, HashTable *properties ZEND_FILE_LINE_DC TSRMLS_DC);
-
-ZEND_API void zend_merge_properties(zval *obj, HashTable *properties, int destroy_ht TSRMLS_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_function(zval *arg, char *key,void (*function_ptr)(INTERNAL_FUNCTION_PARAMETERS));
 
-ZEND_API int add_assoc_long_ex(zval *arg, char *key, uint key_len, long n);
-ZEND_API int add_assoc_null_ex(zval *arg, char *key, uint key_len);
-ZEND_API int add_assoc_bool_ex(zval *arg, char *key, uint key_len, int b);
-ZEND_API int add_assoc_resource_ex(zval *arg, char *key, uint key_len, int r);
-ZEND_API int add_assoc_double_ex(zval *arg, char *key, uint key_len, double d);
-ZEND_API int add_assoc_string_ex(zval *arg, char *key, uint key_len, char *str, int duplicate);
-ZEND_API int add_assoc_stringl_ex(zval *arg, char *key, uint key_len, char *str, uint length, int duplicate);
-ZEND_API int add_assoc_zval_ex(zval *arg, char *key, uint key_len, zval *value);
-
-#define add_assoc_long(__arg, __key, __n) add_assoc_long_ex(__arg, __key, strlen(__key)+1, __n)
-#define add_assoc_null(__arg, __key) add_assoc_null_ex(__arg, __key, strlen(__key) + 1)
-#define add_assoc_bool(__arg, __key, __b) add_assoc_bool_ex(__arg, __key, strlen(__key)+1, __b)
-#define add_assoc_resource(__arg, __key, __r) add_assoc_resource_ex(__arg, __key, strlen(__key)+1, __r)
-#define add_assoc_double(__arg, __key, __d) add_assoc_double_ex(__arg, __key, strlen(__key)+1, __d)
-#define add_assoc_string(__arg, __key, __str, __duplicate) add_assoc_string_ex(__arg, __key, strlen(__key)+1, __str, __duplicate)
-#define add_assoc_stringl(__arg, __key, __str, __length, __duplicate) add_assoc_stringl_ex(__arg, __key, strlen(__key)+1, __str, __length, __duplicate)
-#define add_assoc_zval(__arg, __key, __value) add_assoc_zval_ex(__arg, __key, strlen(__key)+1, __value)
-
-/* unset() functions are only suported for legacy modules and null() functions should be used */
-#define add_assoc_unset(__arg, __key) add_assoc_null_ex(__arg, __key, strlen(__key) + 1)
-#define add_index_unset(__arg, __key) add_index_null(__arg, __key)
-#define add_next_index_unset(__arg) add_next_index_null(__arg)
-#define add_property_unset(__arg, __key) add_property_null(__arg, __key)
+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_null(zval *arg, uint idx);
+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_index_zval(zval *arg, uint index, zval *value);
 
 ZEND_API int add_next_index_long(zval *arg, long n);
-ZEND_API int add_next_index_null(zval *arg);
+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_next_index_zval(zval *arg, zval *value);
-
-ZEND_API int add_get_assoc_string_ex(zval *arg, char *key, uint key_len, char *str, void **dest, int duplicate);
-ZEND_API int add_get_assoc_stringl_ex(zval *arg, char *key, uint key_len, char *str, uint length, void **dest, int duplicate);
-
-#define add_get_assoc_string(__arg, __key, __str, __dest, __duplicate) add_get_assoc_string_ex(__arg, __key, strlen(__key)+1, __str, __dest, __duplicate)
-#define add_get_assoc_stringl(__arg, __key, __str, __length, __dest, __duplicate) add_get_assoc_stringl_ex(__arg, __key, strlen(__key)+1, __str, __length, __dest, __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 add_property_long_ex(zval *arg, char *key, uint key_len, long l TSRMLS_DC);
-ZEND_API int add_property_null_ex(zval *arg, char *key, uint key_len TSRMLS_DC);
-ZEND_API int add_property_bool_ex(zval *arg, char *key, uint key_len, int b TSRMLS_DC);
-ZEND_API int add_property_resource_ex(zval *arg, char *key, uint key_len, long r TSRMLS_DC);
-ZEND_API int add_property_double_ex(zval *arg, char *key, uint key_len, double d TSRMLS_DC);
-ZEND_API int add_property_string_ex(zval *arg, char *key, uint key_len, char *str, int duplicate TSRMLS_DC);
-ZEND_API int add_property_stringl_ex(zval *arg, char *key, uint key_len,  char *str, uint length, int duplicate TSRMLS_DC);
-ZEND_API int add_property_zval_ex(zval *arg, char *key, uint key_len, zval *value TSRMLS_DC);
-
-#define add_property_long(__arg, __key, __n) add_property_long_ex(__arg, __key, strlen(__key)+1, __n TSRMLS_CC)
-#define add_property_null(__arg, __key) add_property_null_ex(__arg, __key, strlen(__key) + 1 TSRMLS_CC)
-#define add_property_bool(__arg, __key, __b) add_property_bool_ex(__arg, __key, strlen(__key)+1, __b TSRMLS_CC)
-#define add_property_resource(__arg, __key, __r) add_property_resource_ex(__arg, __key, strlen(__key)+1, __r TSRMLS_CC)
-#define add_property_double(__arg, __key, __d) add_property_double_ex(__arg, __key, strlen(__key)+1, __d TSRMLS_CC) 
-#define add_property_string(__arg, __key, __str, __duplicate) add_property_string_ex(__arg, __key, strlen(__key)+1, __str, __duplicate TSRMLS_CC)
-#define add_property_stringl(__arg, __key, __str, __length, __duplicate) add_property_stringl_ex(__arg, __key, strlen(__key)+1, __str, __length, __duplicate TSRMLS_CC)
-#define add_property_zval(__arg, __key, __value) add_property_zval_ex(__arg, __key, strlen(__key)+1, __value TSRMLS_CC)       
-
-
-ZEND_API int call_user_function(HashTable *function_table, zval **object_pp, zval *function_name, zval *retval_ptr, zend_uint param_count, zval *params[] TSRMLS_DC);
-ZEND_API int call_user_function_ex(HashTable *function_table, zval **object_pp, zval *function_name, zval **retval_ptr_ptr, zend_uint param_count, zval **params[], int no_separation, HashTable *symbol_table TSRMLS_DC);
-END_EXTERN_C()
-
-typedef struct _zend_fcall_info {
-	size_t size;
-	HashTable *function_table;
-	zval *function_name;
-	HashTable *symbol_table;
-	zval **retval_ptr_ptr;
-	zend_uint param_count;
-	zval ***params;
-	zval **object_pp;
-	zend_bool no_separation;
-} zend_fcall_info;
-
-typedef struct _zend_fcall_info_cache {
-	zend_bool initialized;
-	zend_function *function_handler;
-	zend_class_entry *calling_scope;
-	zval **object_pp;
-} zend_fcall_info_cache;
-
-BEGIN_EXTERN_C()
-ZEND_API extern zend_fcall_info_cache empty_fcall_info_cache;
-
-ZEND_API int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TSRMLS_DC);
+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,
-                                  zend_bool is_ref, int num_symbol_tables, ...);
+                                  int is_ref, int num_symbol_tables, ...);
 
-#define add_method(arg, key, method)	add_assoc_function((arg), (key), (method))
+#define add_method(arg,key,method)	add_assoc_function((arg),(key),(method))
 
-ZEND_API ZEND_FUNCTION(display_disabled_function);
-ZEND_API ZEND_FUNCTION(display_disabled_class);
-END_EXTERN_C()
-
-#if ZEND_DEBUG
-#define CHECK_ZVAL_STRING(z) \
-	if ((z)->value.str.val[ (z)->value.str.len ] != '\0') { zend_error(E_WARNING, "String is not zero-terminated (%s)", (z)->value.str.val); }
-#define CHECK_ZVAL_STRING_REL(z) \
-	if ((z)->value.str.val[ (z)->value.str.len ] != '\0') { zend_error(E_WARNING, "String is not zero-terminated (%s) (source: %s:%d)", (z)->value.str.val ZEND_FILE_LINE_RELAY_CC); }
-#else
-#define CHECK_ZVAL_STRING(z)
-#define CHECK_ZVAL_STRING_REL(z)
-#endif
-
-#define ZVAL_RESOURCE(z, l) {			\
+#define ZVAL_RESOURCE(z,l) {			\
 		(z)->type = IS_RESOURCE;        \
 		(z)->value.lval = l;	        \
 	}
-
-#define ZVAL_BOOL(z, b) {				\
+#define ZVAL_BOOL(z,b) {				\
 		(z)->type = IS_BOOL;	        \
-		(z)->value.lval = ((b) != 0);   \
+		(z)->value.lval = b;	        \
 	}
-
 #define ZVAL_NULL(z) {					\
 		(z)->type = IS_NULL;	        \
 	}
-
-#define ZVAL_LONG(z, l) {				\
+#define ZVAL_LONG(z,l) {				\
 		(z)->type = IS_LONG;	        \
 		(z)->value.lval = l;	        \
 	}
-
-#define ZVAL_DOUBLE(z, d) {				\
+#define ZVAL_DOUBLE(z,d) {				\
 		(z)->type = IS_DOUBLE;	        \
 		(z)->value.dval = d;	        \
 	}
-
-#define ZVAL_STRING(z, s, duplicate) {	\
+#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)->value.str.val = (duplicate?estrndup(__s,(z)->value.str.len):__s);	\
 		(z)->type = IS_STRING;	        \
 	}
-
-#define ZVAL_STRINGL(z, s, l, duplicate) {	\
+#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)->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 = STR_EMPTY_ALLOC(); \
+		(z)->value.str.val = empty_string; \
 		(z)->type = IS_STRING;		    \
 	}
 
-#define ZVAL_ZVAL(z, zv, copy, dtor) {  \
-		int is_ref, refcount;           \
-		is_ref = (z)->is_ref;           \
-		refcount = (z)->refcount;       \
-		*(z) = *(zv);                   \
-		if (copy) {                     \
-			zval_copy_ctor(z);          \
-	    }                               \
-		if (dtor) {                     \
-			if (!copy) {                \
-				ZVAL_NULL(zv);          \
-			}                           \
-			zval_ptr_dtor(&zv);         \
-	    }                               \
-		(z)->is_ref = is_ref;           \
-		(z)->refcount = refcount;       \
+#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 ZVAL_FALSE(z)  					ZVAL_BOOL(z, 0)
-#define ZVAL_TRUE(z)  					ZVAL_BOOL(z, 1)
+#define RETVAL_EMPTY_STRING() {	            \
+		return_value->value.str.len = 0;  	\
+		return_value->value.str.val = empty_string; \
+		return_value->type = IS_STRING;		\
+	}
 
-#define RETVAL_RESOURCE(l)				ZVAL_RESOURCE(return_value, l)
-#define RETVAL_BOOL(b)					ZVAL_BOOL(return_value, b)
-#define RETVAL_NULL() 					ZVAL_NULL(return_value)
-#define RETVAL_LONG(l) 					ZVAL_LONG(return_value, l)
-#define RETVAL_DOUBLE(d) 				ZVAL_DOUBLE(return_value, d)
-#define RETVAL_STRING(s, duplicate) 		ZVAL_STRING(return_value, s, duplicate)
-#define RETVAL_STRINGL(s, l, duplicate) 	ZVAL_STRINGL(return_value, s, l, duplicate)
-#define RETVAL_EMPTY_STRING() 			ZVAL_EMPTY_STRING(return_value)
-#define RETVAL_ZVAL(zv, copy, dtor)		ZVAL_ZVAL(return_value, zv, copy, dtor)
-#define RETVAL_FALSE  					ZVAL_BOOL(return_value, 0)
-#define RETVAL_TRUE   					ZVAL_BOOL(return_value, 1)
+#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) 				{ RETVAL_RESOURCE(l); return; }
-#define RETURN_BOOL(b) 					{ RETVAL_BOOL(b); return; }
-#define RETURN_NULL() 					{ RETVAL_NULL(); return;}
-#define RETURN_LONG(l) 					{ RETVAL_LONG(l); return; }
-#define RETURN_DOUBLE(d) 				{ RETVAL_DOUBLE(d); return; }
-#define RETURN_STRING(s, duplicate) 	{ RETVAL_STRING(s, duplicate); return; }
-#define RETURN_STRINGL(s, l, duplicate) { RETVAL_STRINGL(s, l, duplicate); return; }
-#define RETURN_EMPTY_STRING() 			{ RETVAL_EMPTY_STRING(); return; }
-#define RETURN_ZVAL(zv, copy, dtor)		{ RETVAL_ZVAL(zv, copy, dtor); return; }
-#define RETURN_FALSE  					{ RETVAL_FALSE; return; }
-#define RETURN_TRUE   					{ RETVAL_TRUE; return; }
+#define RETURN_RESOURCE(l) {			\
+		return_value->type = IS_RESOURCE;\
+		return_value->value.lval = l;	\
+		return;							\
+	}
 
-#define SET_VAR_STRING(n, v) {																				\
+#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);														\
-									ZVAL_STRING(var, v, 0);													\
+									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) {														\
+#define SET_VAR_STRINGL(n,v,l)	{														\
 									{													\
 										zval *var;										\
+																						\
 										ALLOC_ZVAL(var);								\
-										ZVAL_STRINGL(var, v, l, 0);						\
+										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)	{															\
+#define SET_VAR_LONG(n,v)	{															\
 								{														\
 									zval *var;											\
+																						\
 									ALLOC_ZVAL(var);									\
-									ZVAL_LONG(var, v);									\
+									var->value.lval = (v);								\
+									var->type = IS_LONG;								\
 									ZEND_SET_GLOBAL_VAR(n, var);						\
 								}														\
 							}
 
-#define SET_VAR_DOUBLE(n, v) {															\
+#define SET_VAR_DOUBLE(n,v)	{															\
 								{														\
 									zval *var;											\
+																						\
 									ALLOC_ZVAL(var);									\
-									ZVAL_DOUBLE(var, v);								\
+									var->value.dval = (v);								\
+									var->type = IS_DOUBLE;								\
 									ZEND_SET_GLOBAL_VAR(n, var);						\
 								}														\
 							}
@@ -509,38 +413,14 @@ END_EXTERN_C()
 #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 ZEND_DEFINE_PROPERTY(class_ptr, name, value, mask)								\
-{																					\
-	char *_name = (name);															\
-	int namelen = strlen(_name);													\
-	zend_declare_property(class_ptr, _name, namelen, value, mask TSRMLS_CC);		\
-}
-
-#define HASH_OF(p) ((p)->type==IS_ARRAY ? (p)->value.ht : (((p)->type==IS_OBJECT ? Z_OBJ_HT_P(p)->get_properties((p) TSRMLS_CC) : NULL)))
+#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)
 
-/* For compatibility */
-#define ZEND_MINIT			ZEND_MODULE_STARTUP_N
-#define ZEND_MSHUTDOWN		ZEND_MODULE_SHUTDOWN_N
-#define ZEND_RINIT			ZEND_MODULE_ACTIVATE_N
-#define ZEND_RSHUTDOWN		ZEND_MODULE_DEACTIVATE_N
-#define ZEND_MINFO			ZEND_MODULE_INFO_N
-
-#define ZEND_MINIT_FUNCTION			ZEND_MODULE_STARTUP_D
-#define ZEND_MSHUTDOWN_FUNCTION		ZEND_MODULE_SHUTDOWN_D
-#define ZEND_RINIT_FUNCTION			ZEND_MODULE_ACTIVATE_D
-#define ZEND_RSHUTDOWN_FUNCTION		ZEND_MODULE_DEACTIVATE_D
-#define ZEND_MINFO_FUNCTION			ZEND_MODULE_INFO_D
-
-END_EXTERN_C()
-	
 #endif /* ZEND_API_H */
 
-
 /*
  * Local variables:
  * tab-width: 4
  * c-basic-offset: 4
- * indent-tabs-mode: t
  * End:
  */

Zend/zend_alloc.c

@@ -2,12 +2,12 @@
    +----------------------------------------------------------------------+
    | Zend Engine                                                          |
    +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2004 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
    +----------------------------------------------------------------------+
-   | This source file is subject to version 2.00 of the Zend license,     |
+   | 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 through the world-wide-web at the following url:           |
-   | http://www.zend.com/license/2_00.txt.                                |
+   | 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.              |
@@ -17,7 +17,8 @@
    +----------------------------------------------------------------------+
 */
 
-/* $Id$ */
+
+#include <stdlib.h>
 
 #include "zend.h"
 #include "zend_alloc.h"
@@ -30,38 +31,20 @@
 # include <unistd.h>
 #endif
 
-#include "zend_mm.h"
-
 #ifndef ZTS
 ZEND_API zend_alloc_globals alloc_globals;
 #endif
 
 
-#ifdef ZEND_MM
 #define ZEND_DISABLE_MEMORY_CACHE 0
-#else
-#define ZEND_DISABLE_MEMORY_CACHE 0
-#endif
 
-#ifdef ZEND_MM
-#define ZEND_DO_MALLOC(size)		zend_mm_alloc(&AG(mm_heap), size)
-#define ZEND_DO_FREE(ptr)			zend_mm_free(&AG(mm_heap), ptr)
-#define ZEND_DO_REALLOC(ptr, size)	zend_mm_realloc(&AG(mm_heap), ptr, size)
-#elif defined(ZEND_WIN32)
-#define ZEND_DO_MALLOC(size)		(AG(memory_heap) ? HeapAlloc(AG(memory_heap), HEAP_NO_SERIALIZE, size) : malloc(size))
-#define ZEND_DO_FREE(ptr)			(AG(memory_heap) ? HeapFree(AG(memory_heap), HEAP_NO_SERIALIZE, ptr) : free(ptr))
-#define ZEND_DO_REALLOC(ptr, size)	(AG(memory_heap) ? HeapReAlloc(AG(memory_heap), HEAP_NO_SERIALIZE, ptr, size) : realloc(ptr, size))
-#else
-#define ZEND_DO_MALLOC(size)		malloc(size)
-#define ZEND_DO_FREE(ptr)			free(ptr)
-#define ZEND_DO_REALLOC(ptr, size)	realloc(ptr, size)
-#endif
 
 #if ZEND_DEBUG
 # define END_MAGIC_SIZE sizeof(long)
-static long mem_block_end_magic = MEM_BLOCK_END_MAGIC;
+# 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
 
 
@@ -69,27 +52,23 @@ static long mem_block_end_magic = MEM_BLOCK_END_MAGIC;
 #  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)
+#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)) {\
-									int php_mem_limit = AG(memory_limit); \
-									if (EG(in_execution) && AG(memory_limit)+1048576 > AG(allocated_memory) - rs) { \
-										AG(memory_limit) = AG(allocated_memory) + 1048576; \
-										if (file) { \
-											zend_error(E_ERROR,"Allowed memory size of %d bytes exhausted at %s:%d (tried to allocate %d bytes)", php_mem_limit, file, lineno, s); \
+									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 (tried to allocate %d bytes)", php_mem_limit, s); \
+											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); \
 										} \
-									} else { \
-										if (file) { \
-											fprintf(stderr, "Allowed memory size of %d bytes exhausted at %s:%d (tried to allocate %d bytes)\n", php_mem_limit, file, lineno, s); \
-										} else { \
-											fprintf(stderr, "Allowed memory size of %d bytes exhausted (tried to allocate %d bytes)\n", php_mem_limit, s); \
-										} \
-										exit(1); \
-									} \
+										AG(memory_exhausted)=1;	\
+									}	\
 								} \
 							}
 # endif
@@ -99,35 +78,37 @@ static long mem_block_end_magic = MEM_BLOCK_END_MAGIC;
 #endif
 
 
-#if ZEND_DEBUG || !defined(ZEND_MM)
 #define REMOVE_POINTER_FROM_LIST(p)				\
-	if (p==AG(head)) {							\
+	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;				\
 	}
-#else
-#define REMOVE_POINTER_FROM_LIST(p)
-#endif
 
-#if ZEND_DEBUG || !defined(ZEND_MM)
-#define ADD_POINTER_TO_LIST(p)	\
-	p->pNext = AG(head);		\
-	if (AG(head)) {				\
-		AG(head)->pLast = p;	\
-	}							\
-	AG(head) = p;				\
+#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;
-#else
-#define ADD_POINTER_TO_LIST(p)
-#endif
 
-#define DECLARE_CACHE_VARS()	\
+#define DECLARE_CACHE_VARS		\
 	unsigned int real_size;		\
-	unsigned int cache_index
+	unsigned int cache_index;
 
 #define REAL_SIZE(size) ((size+7) & ~0x7)
 
@@ -142,13 +123,12 @@ static long mem_block_end_magic = MEM_BLOCK_END_MAGIC;
 ZEND_API void *_emalloc(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
 {
 	zend_mem_header *p;
-	DECLARE_CACHE_VARS();
-	TSRMLS_FETCH();
+	DECLARE_CACHE_VARS
+	ALS_FETCH();
 
 	CALCULATE_REAL_SIZE_AND_CACHE_INDEX(size);
 
-#if !ZEND_DISABLE_MEMORY_CACHE
-	if ((CACHE_INDEX < MAX_CACHED_MEMORY) && (AG(cache_count)[CACHE_INDEX] > 0)) {
+	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;
@@ -157,31 +137,23 @@ ZEND_API void *_emalloc(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
 		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]++;
-		memcpy((((char *) p) + sizeof(zend_mem_header) + MEM_HEADER_PADDING + size), &mem_block_end_magic, sizeof(long));
 #endif
+		p->persistent = 0;
+		p->cached = 0;
 		p->size = size;
-		return (void *)((char *)p + sizeof(zend_mem_header) + MEM_HEADER_PADDING);
+		HANDLE_BLOCK_INTERRUPTIONS();
+		ADD_POINTER_TO_LIST(p);
+		HANDLE_UNBLOCK_INTERRUPTIONS();
+		return (void *)((char *)p + sizeof(zend_mem_header) + PLATFORM_PADDING);
 	} else {
-#endif
 #if ZEND_DEBUG
 		if (CACHE_INDEX<MAX_CACHED_MEMORY) {
 			AG(cache_stats)[CACHE_INDEX][0]++;
 		}
 #endif
-#if MEMORY_LIMIT
-		CHECK_MEMORY_LIMIT(size, SIZE);
-		if (AG(allocated_memory) > AG(allocated_memory_peak)) {
-			AG(allocated_memory_peak) = AG(allocated_memory);
-		}
-#endif
-		p  = (zend_mem_header *) ZEND_DO_MALLOC(sizeof(zend_mem_header) + MEM_HEADER_PADDING + SIZE + END_MAGIC_SIZE);
-#if !ZEND_DISABLE_MEMORY_CACHE
+		p  = (zend_mem_header *) malloc(sizeof(zend_mem_header) + SIZE + PLATFORM_PADDING + END_ALIGNMENT(SIZE) + END_MAGIC_SIZE);
 	}
-#endif
 
 	HANDLE_BLOCK_INTERRUPTIONS();
 
@@ -195,6 +167,7 @@ ZEND_API void *_emalloc(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
 		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
@@ -204,100 +177,42 @@ ZEND_API void *_emalloc(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
 	p->orig_lineno = __zend_orig_lineno;
 	p->magic = MEM_BLOCK_START_MAGIC;
 	p->reported = 0;
-# ifdef ZTS
-	p->thread_id = tsrm_thread_id();
-# endif
-	memcpy((((char *) p) + sizeof(zend_mem_header) + MEM_HEADER_PADDING + size), &mem_block_end_magic, sizeof(long));
+	*((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) + MEM_HEADER_PADDING);
-}
-
-#include "zend_multiply.h"
-
-ZEND_API void *_safe_emalloc(size_t nmemb, size_t size, size_t offset ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
-{
-
-	if (nmemb < LONG_MAX
-			&& size < LONG_MAX
-			&& offset < LONG_MAX
-			&& nmemb >= 0
-			&& size >= 0
-			&& offset >= 0) {
-		long lval;
-		double dval;
-		int use_dval;
-
-		ZEND_SIGNED_MULTIPLY_LONG(nmemb, size, lval, dval, use_dval);
-
-		if (!use_dval
-				&& lval < (long) (LONG_MAX - offset)) {
-			return emalloc_rel(lval + offset);
-		}
-	}
-
-	zend_error(E_ERROR, "Possible integer overflow in memory allocation (%zd * %zd + %zd)", nmemb, size, offset);
-	return 0;
-}
-
-ZEND_API void *_safe_malloc(size_t nmemb, size_t size, size_t offset)
-{
-
-	if (nmemb < LONG_MAX
-			&& size < LONG_MAX
-			&& offset < LONG_MAX
-			&& nmemb >= 0
-			&& size >= 0
-			&& offset >= 0) {
-		long lval;
-		double dval;
-		int use_dval;
-
-		ZEND_SIGNED_MULTIPLY_LONG(nmemb, size, lval, dval, use_dval);
-
-		if (!use_dval
-				&& lval < (long) (LONG_MAX - offset)) {
-			return pemalloc(lval + offset, 1);
-		}
-	}
-
-	zend_error(E_ERROR, "Possible integer overflow in memory allocation (%zd * %zd + %zd)", nmemb, size, offset);
-	return 0;
+	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) - MEM_HEADER_PADDING);
-	DECLARE_CACHE_VARS();
-	TSRMLS_FETCH();
-
-#if defined(ZTS) && TSRM_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
+	zend_mem_header *p = (zend_mem_header *) ((char *)ptr - sizeof(zend_mem_header) - PLATFORM_PADDING);
+	DECLARE_CACHE_VARS
+	ALS_FETCH();
 
 	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, p->size);
+	memset(ptr, 0x5a, SIZE);
 #endif
-#if !ZEND_DISABLE_MEMORY_CACHE
-	if ((CACHE_INDEX < MAX_CACHED_MEMORY) && (AG(cache_count)[CACHE_INDEX] < MAX_CACHED_ENTRIES)) {
+
+	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;
 	}
-#endif
 	HANDLE_BLOCK_INTERRUPTIONS();
 	REMOVE_POINTER_FROM_LIST(p);
 
@@ -305,7 +220,7 @@ ZEND_API void _efree(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
 	AG(allocated_memory) -= SIZE;
 #endif
 	
-	ZEND_DO_FREE(p);
+	free(p);
 	HANDLE_UNBLOCK_INTERRUPTIONS();
 }
 
@@ -313,7 +228,7 @@ 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)
 {
 	void *p;
-	int final_size = size*nmemb;
+	int final_size=size*nmemb;
 	
 	HANDLE_BLOCK_INTERRUPTIONS();
 	p = _emalloc(final_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
@@ -321,7 +236,7 @@ ZEND_API void *_ecalloc(size_t nmemb, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LI
 		HANDLE_UNBLOCK_INTERRUPTIONS();
 		return (void *) p;
 	}
-	memset(p, 0, final_size);
+	memset(p,(int)NULL, final_size);
 	HANDLE_UNBLOCK_INTERRUPTIONS();
 	return p;
 }
@@ -329,41 +244,20 @@ ZEND_API void *_ecalloc(size_t nmemb, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LI
 
 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 *orig;
-	DECLARE_CACHE_VARS();
-	TSRMLS_FETCH();
+	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);
 	}
 
-	p = orig = (zend_mem_header *) ((char *)ptr-sizeof(zend_mem_header)-MEM_HEADER_PADDING);
-
-#if defined(ZTS) && TSRM_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();
-#if MEMORY_LIMIT
-	CHECK_MEMORY_LIMIT(size - p->size, SIZE - REAL_SIZE(p->size));
-	if (AG(allocated_memory) > AG(allocated_memory_peak)) {
-		AG(allocated_memory_peak) = AG(allocated_memory);
-	}
-#endif
 	REMOVE_POINTER_FROM_LIST(p);
-	p = (zend_mem_header *) ZEND_DO_REALLOC(p, sizeof(zend_mem_header)+MEM_HEADER_PADDING+SIZE+END_MAGIC_SIZE);
+	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);
@@ -382,13 +276,15 @@ ZEND_API void *_erealloc(void *ptr, size_t size, int allow_failure ZEND_FILE_LIN
 	p->filename = __zend_filename;
 	p->lineno = __zend_lineno;
 	p->magic = MEM_BLOCK_START_MAGIC;
-	memcpy((((char *) p) + sizeof(zend_mem_header) + MEM_HEADER_PADDING + size), &mem_block_end_magic, sizeof(long));
+	*((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)+MEM_HEADER_PADDING);
+	return (void *)((char *)p+sizeof(zend_mem_header)+PLATFORM_PADDING);
 }
 
 
@@ -405,7 +301,7 @@ ZEND_API char *_estrdup(const char *s ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
 		return (char *)NULL;
 	}
 	HANDLE_UNBLOCK_INTERRUPTIONS();
-	memcpy(p, s, length);
+	memcpy(p,s,length);
 	return p;
 }
 
@@ -421,8 +317,8 @@ ZEND_API char *_estrndup(const char *s, uint length ZEND_FILE_LINE_DC ZEND_FILE_
 		return (char *)NULL;
 	}
 	HANDLE_UNBLOCK_INTERRUPTIONS();
-	memcpy(p, s, length);
-	p[length] = 0;
+	memcpy(p,s,length);
+	p[length]=0;
 	return p;
 }
 
@@ -436,9 +332,9 @@ ZEND_API char *zend_strndup(const char *s, uint length)
 		return (char *)NULL;
 	}
 	if (length) {
-		memcpy(p, s, length);
+		memcpy(p,s,length);
 	}
-	p[length] = 0;
+	p[length]=0;
 	return p;
 }
 
@@ -446,7 +342,7 @@ ZEND_API char *zend_strndup(const char *s, uint length)
 ZEND_API int zend_set_memory_limit(unsigned int memory_limit)
 {
 #if MEMORY_LIMIT
-	TSRMLS_FETCH();
+	ALS_FETCH();
 
 	AG(memory_limit) = memory_limit;
 	return SUCCESS;
@@ -456,28 +352,39 @@ ZEND_API int zend_set_memory_limit(unsigned int memory_limit)
 }
 
 
-ZEND_API void start_memory_manager(TSRMLS_D)
+ZEND_API void start_memory_manager(ALS_D)
 {
-	AG(head) = NULL;
+#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;		/* ridiculous limit, effectively no limit */
-	AG(allocated_memory) = 0;
-	AG(memory_exhausted) = 0;
-	AG(allocated_memory_peak) = 0;
+	AG(memory_limit)=1<<30;		/* rediculous limit, effectively no limit */
+	AG(allocated_memory)=0;
+	AG(memory_exhausted)=0;
 #endif
 
-#if ZEND_ENABLE_FAST_CACHE
 	memset(AG(fast_cache_list_head), 0, sizeof(AG(fast_cache_list_head)));
-#endif
-#if !ZEND_DISABLE_MEMORY_CACHE
-	memset(AG(cache_count), 0, sizeof(AG(cache_count)));
-#endif
+	memset(AG(cache_count),0,sizeof(AG(cache_count)));
 
-#ifdef ZEND_MM
-	zend_mm_startup(&AG(mm_heap), 256*1024);
-#elif defined(ZEND_WIN32)
-	AG(memory_heap) = HeapCreate(HEAP_NO_SERIALIZE, 256*1024, 0);
+#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
@@ -487,124 +394,87 @@ ZEND_API void start_memory_manager(TSRMLS_D)
 }
 
 
-ZEND_API void shutdown_memory_manager(int silent, int full_shutdown TSRMLS_DC)
+ZEND_API void shutdown_memory_manager(int silent, int clean_cache)
 {
-#if ZEND_DEBUG || !defined(ZEND_MM)
 	zend_mem_header *p, *t;
-#endif
+	unsigned int fci, i, j;
 #if ZEND_DEBUG
-	zend_uint grand_total_leaks=0;
+	int had_leaks=0;
 #endif
+	zend_fast_cache_list_entry *fast_cache_list_entry, *next_fast_cache_list_entry;
+	ALS_FETCH();
 
-#if !ZEND_DISABLE_MEMORY_CACHE
-	/* Free memory cache even on partial shutdown to avoid fragmentation */
-	if (1 || full_shutdown) {
-		unsigned int i, j;
-		zend_mem_header *ptr;
-
-		for (i=0; i<MAX_CACHED_MEMORY; i++) {
-			for (j=0; j<AG(cache_count)[i]; j++) {
-				ptr = (zend_mem_header *) AG(cache)[i][j];
-#  if MEMORY_LIMIT
-				AG(allocated_memory) -= REAL_SIZE(ptr->size);
-#  endif
-				REMOVE_POINTER_FROM_LIST(ptr);
-				ZEND_DO_FREE(ptr);
-			}
-			AG(cache_count)[i] = 0;
+	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;
 	}
-#endif /* !ZEND_DISABLE_MEMORY_CACHE */
 
-#if defined(ZEND_MM) && !ZEND_DEBUG
-	zend_mm_shutdown(&AG(mm_heap));
-	if (full_shutdown) {
-		return;
-	}
-	zend_mm_startup(&AG(mm_heap), 256*1024);
-
-#elif defined(ZEND_WIN32) && !ZEND_DEBUG
-	if (full_shutdown && AG(memory_heap)) {
-		HeapDestroy(AG(memory_heap));
-		return;
-	}
-#endif
-
-#if ZEND_ENABLE_FAST_CACHE
-	{
-		zend_fast_cache_list_entry *fast_cache_list_entry, *next_fast_cache_list_entry;
-		unsigned int fci;
-
-		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;
-		}
-	}
-#endif /* ZEND_ENABLE_FAST_CACHE */
-
-#if ZEND_DEBUG || !defined(ZEND_MM)
-	p = AG(head);
-	t = AG(head);
+	p=AG(head);
+	t=AG(head);
 	while (t) {
+		if (!t->cached || clean_cache) {
 #if ZEND_DEBUG
-		if (!t->reported) {
-			zend_mem_header *iterator;
-			int total_leak=0, total_leak_count=0;
+			if (!t->cached && !t->reported) {
+				zend_mem_header *iterator;
+				int total_leak=0, total_leak_count=0;
 
-			grand_total_leaks++;
-			if (!silent) {
-				zend_message_dispatcher(ZMSG_MEMORY_LEAK_DETECTED, t);
-			}
-			t->reported = 1;
-			for (iterator=t->pNext; iterator; iterator=iterator->pNext) {
-				if (iterator->filename==t->filename && iterator->lineno==t->lineno) {
-					total_leak += iterator->size;
-					total_leak_count++;
-					iterator->reported = 1;
+				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));
 				}
 			}
-			if (!silent && total_leak_count>0) {
-				zend_message_dispatcher(ZMSG_MEMORY_LEAK_REPEATED, (void *) (long) (total_leak_count));
-			}
-			grand_total_leaks += total_leak_count;
-		}
 #endif
 #if MEMORY_LIMIT
-		AG(allocated_memory) -= REAL_SIZE(t->size);
+			AG(allocated_memory) -= t->size;
 #endif
-		p = t->pNext;
-		REMOVE_POINTER_FROM_LIST(t);
-		ZEND_DO_FREE(t);
-		t = p;
+			p = t->pNext;
+			REMOVE_POINTER_FROM_LIST(t);
+			free(t);
+			t = p;
+		} else {
+			t = t->pNext;
+		}
 	}
 
-#if ZEND_DEBUG
-	if (!silent && grand_total_leaks > 0) {
-		zend_message_dispatcher(ZMSG_MEMORY_LEAKS_GRAND_TOTAL, &grand_total_leaks);
+	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]);
+			}
+		}
 	}
-#endif
-
 #if MEMORY_LIMIT
 	AG(memory_exhausted)=0;
-	AG(allocated_memory_peak) = 0;
 #endif
 
-
 #if (ZEND_DEBUG)
 	do {
 		zval display_memory_cache_stats;
 		int i, j;
 
-		if (full_shutdown) {
+		if (clean_cache) {
 			/* we're shutting down completely, don't even touch the INI subsystem */
 			break;
 		}
-		if (zend_get_configuration_directive("display_memory_cache_stats", sizeof("display_memory_cache_stats"), &display_memory_cache_stats)==FAILURE) {
+		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)) {
@@ -634,21 +504,6 @@ ZEND_API void shutdown_memory_manager(int silent, int full_shutdown TSRMLS_DC)
 					
 	} while (0);
 #endif
-
-#endif
-
-#if defined(ZEND_MM) && ZEND_DEBUG
-	zend_mm_shutdown(&AG(mm_heap));
-	if (full_shutdown) {
-		return;
-	}
-	zend_mm_startup(&AG(mm_heap), 256*1024);
-#elif defined(ZEND_WIN32) && ZEND_DEBUG
-	if (full_shutdown && AG(memory_heap)) {
-		HeapDestroy(AG(memory_heap));
-		return;
-	}
-#endif
 }
 
 
@@ -672,19 +527,18 @@ void zend_debug_alloc_output(char *format, ...)
 
 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) - MEM_HEADER_PADDING);
+	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;
-	long end_magic;
 
 	if (silent==2) {
-		silent = 1;
-		no_cache_notice = 1;
+		silent=1;
+		no_cache_notice=1;
 	}
 	if (silent==3) {
-		silent = 0;
-		no_cache_notice = 1;
+		silent=0;
+		no_cache_notice=1;
 	}
 	if (!silent) {
 		zend_message_dispatcher(ZMSG_LOG_SCRIPT_NAME, NULL);
@@ -705,7 +559,7 @@ ZEND_API int _mem_block_check(void *ptr, int silent ZEND_FILE_LINE_DC ZEND_FILE_
 		case MEM_BLOCK_FREED_MAGIC:
 			if (!silent) {
 				zend_debug_alloc_output("Freed\n");
-				had_problems = 1;
+				had_problems=1;
 			} else {
 				return _mem_block_check(ptr, 0 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
 			}
@@ -714,7 +568,7 @@ ZEND_API int _mem_block_check(void *ptr, int silent ZEND_FILE_LINE_DC ZEND_FILE_
 			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;
+					had_problems=1;
 				}
 			} else {
 				if (!no_cache_notice) {
@@ -728,35 +582,36 @@ ZEND_API int _mem_block_check(void *ptr, int silent ZEND_FILE_LINE_DC ZEND_FILE_
 			} else {
 				return _mem_block_check(ptr, 0 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
 			}
-			had_problems = 1;
-			valid_beginning = 0;
+			had_problems=1;
+			valid_beginning=0;
 			break;
 	}
 
 
-	memcpy(&end_magic, (((char *) p)+sizeof(zend_mem_header)+MEM_HEADER_PADDING+p->size), sizeof(long));
-
-	if (valid_beginning && (end_magic != MEM_BLOCK_END_MAGIC)) {
-		char *overflow_ptr, *magic_ptr=(char *) &mem_block_end_magic;
+	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;
-		long i;
+		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 *) &end_magic;
+		had_problems=1;
+		overflow_ptr = ((char *) p)+sizeof(zend_mem_header)+REAL_SIZE(p->size)+PLATFORM_PADDING;
 
-		for (i=0; i<(int)sizeof(long); i++) {
+		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", end_magic, MEM_BLOCK_END_MAGIC);
+		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>=(int)sizeof(long)) {
+		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);
@@ -769,6 +624,12 @@ ZEND_API int _mem_block_check(void *ptr, int silent ZEND_FILE_LINE_DC ZEND_FILE_
 			zend_debug_alloc_output("Unknown\n");
 		}
 	}
+
+	if (had_problems) {
+		int foo = 5;
+
+		foo+=1;
+	}
 		
 	if (!silent) {
 		zend_debug_alloc_output("---------------------------------------\n");
@@ -781,7 +642,7 @@ ZEND_API void _full_mem_check(int silent ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_D
 {
 	zend_mem_header *p;
 	int errors=0;
-	TSRMLS_FETCH();
+	ALS_FETCH();
 
 	p = AG(head);
 	
@@ -790,7 +651,7 @@ ZEND_API void _full_mem_check(int silent ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_D
 	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) + MEM_HEADER_PADDING), (silent?2:3) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC)) {
+		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;
@@ -800,10 +661,33 @@ ZEND_API void _full_mem_check(int silent ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_D
 }
 #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
- * indent-tabs-mode: t
  * End:
  */

Zend/zend_alloc.h

@@ -2,12 +2,12 @@
    +----------------------------------------------------------------------+
    | Zend Engine                                                          |
    +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2004 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
    +----------------------------------------------------------------------+
-   | This source file is subject to version 2.00 of the Zend license,     |
+   | 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 through the world-wide-web at the following url:           |
-   | http://www.zend.com/license/2_00.txt.                                |
+   | 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.              |
@@ -17,20 +17,16 @@
    +----------------------------------------------------------------------+
 */
 
-/* $Id$ */
 
 #ifndef ZEND_ALLOC_H
 #define ZEND_ALLOC_H
 
 #include <stdio.h>
 
-#include "../TSRM/TSRM.h"
 #include "zend_globals_macros.h"
 
-#include "zend_mm.h"
-
 #define MEM_BLOCK_START_MAGIC	0x7312F8DCL
-#define MEM_BLOCK_END_MAGIC		0x2A8FCC84L
+#define MEM_BLOCK_END_MAGIC	0x2A8FCC84L
 #define MEM_BLOCK_FREED_MAGIC	0x99954317L
 #define MEM_BLOCK_CACHED_MAGIC	0xFB8277DCL
 
@@ -42,15 +38,12 @@ typedef struct _zend_mem_header {
 	int reported;
 	char *orig_filename;
 	uint orig_lineno;
-# ifdef ZTS
-	THREAD_T thread_id;
-# endif
 #endif
-#if ZEND_DEBUG || !defined(ZEND_MM)
     struct _zend_mem_header *pNext;
     struct _zend_mem_header *pLast;
-#endif
-	unsigned int size;
+	unsigned int size:30;
+	unsigned int persistent:1;
+	unsigned int cached:1;
 } zend_mem_header;
 
 typedef union _align_test {
@@ -63,122 +56,61 @@ typedef union _align_test {
 #define MAX_CACHED_ENTRIES	256
 #define PRE_INIT_CACHE_ENTRIES	32
 
-#if ZEND_GCC_VERSION >= 2000
-# define PLATFORM_ALIGNMENT (__alignof__ (align_test))
+#if (defined (__GNUC__) && __GNUC__ >= 2)
+#define PLATFORM_ALIGNMENT (__alignof__ (align_test))
 #else
-# define PLATFORM_ALIGNMENT (sizeof(align_test))
+#define PLATFORM_ALIGNMENT (sizeof(align_test))
 #endif
 
-#define MEM_HEADER_PADDING (((PLATFORM_ALIGNMENT-sizeof(zend_mem_header))%PLATFORM_ALIGNMENT+PLATFORM_ALIGNMENT)%PLATFORM_ALIGNMENT)
+#define PLATFORM_PADDING (((PLATFORM_ALIGNMENT-sizeof(zend_mem_header))%PLATFORM_ALIGNMENT+PLATFORM_ALIGNMENT)%PLATFORM_ALIGNMENT)
 
+ZEND_API char *zend_strndup(const char *s, unsigned int length);
 
 BEGIN_EXTERN_C()
 
-ZEND_API char *zend_strndup(const char *s, unsigned int length) ZEND_ATTRIBUTE_MALLOC;
-
-ZEND_API void *_emalloc(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC;
-ZEND_API void *_safe_emalloc(size_t nmemb, size_t size, size_t offset ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC;
-ZEND_API void *_safe_malloc(size_t nmemb, size_t size, size_t offset) ZEND_ATTRIBUTE_MALLOC;
+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_ATTRIBUTE_MALLOC;
+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_ATTRIBUTE_MALLOC;
-ZEND_API char *_estrndup(const char *s, unsigned int length ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC;
-
-#define USE_ZEND_ALLOC 1
-
-#if USE_ZEND_ALLOC
+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 safe_emalloc(nmemb, size, offset)       _safe_emalloc((nmemb), (size), (offset) 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 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 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 safe_emalloc_rel(nmemb, size, offset)   _safe_emalloc((nmemb), (size), (offset) 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 safe_pemalloc(nmemb, size, offset, persistent)	((persistent)?_safe_malloc(nmemb, size, offset):safe_emalloc(nmemb, size, offset))
-#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 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 pemalloc_rel(size, persistent) ((persistent)?malloc(size):emalloc_rel(size))
-#define pefree_rel(ptr, persistent)	((persistent)?free(ptr):efree_rel(ptr))
-#define pecalloc_rel(nmemb, size, persistent) ((persistent)?calloc((nmemb), (size)):ecalloc_rel((nmemb), (size)))
-#define perealloc_rel(ptr, size, persistent) ((persistent)?realloc((ptr), (size)):erealloc_rel((ptr), (size)))
-#define perealloc_recoverable_rel(ptr, size, persistent) ((persistent)?realloc((ptr), (size)):erealloc_recoverable_rel((ptr), (size)))
-#define pestrdup_rel(s, persistent) ((persistent)?strdup(s):estrdup_rel(s))
-
-#define safe_estrdup(ptr)  ((ptr)?(estrdup(ptr)):STR_EMPTY_ALLOC())
-#define safe_estrndup(ptr, len) ((ptr)?(estrndup((ptr), (len))):STR_EMPTY_ALLOC())
-
-#else
-
-#define _GNU_SOURCE
-#include <string.h>
-#undef _GNU_SOURCE
-
-/* Standard wrapper macros */
-#define emalloc(size)					malloc(size)
-#define safe_emalloc(nmemb, size, offset)		malloc((nmemb) * (size) + (offset))
-#define efree(ptr)						free(ptr)
-#define ecalloc(nmemb, size)			calloc((nmemb), (size))
-#define erealloc(ptr, size)				realloc((ptr), (size))
-#define erealloc_recoverable(ptr, size)	realloc((ptr), (size))
-#define estrdup(s)						strdup(s)
-#define estrndup(s, length)				strndup((s), (length))
-
-/* Relay wrapper macros */
-#define emalloc_rel(size)					malloc(size)
-#define safe_emalloc_rel(nmemb, size, offset)		malloc((nmemb) * (size) + (offset))
-#define efree_rel(ptr)						free(ptr)
-#define ecalloc_rel(nmemb, size)			calloc((nmemb), (size))
-#define erealloc_rel(ptr, size)				realloc((ptr), (size))
-#define erealloc_recoverable_rel(ptr, size)	realloc((ptr), (size))
-#define estrdup_rel(s)						strdup(s)
-#define estrndup_rel(s, length)				strndup((s), (length))
-
-/* Selective persistent/non persistent allocation macros */
-#define pemalloc(size, persistent)		malloc(size)
-#define safe_pemalloc(nmemb, size, offset, persistent)		malloc((nmemb) * (size) + (offset))
-#define pefree(ptr, persistent)			free(ptr)
-#define pecalloc(nmemb, size, persistent)		calloc((nmemb), (size))
-#define perealloc(ptr, size, persistent)		realloc((ptr), (size))
-#define perealloc_recoverable(ptr, size, persistent)	realloc((ptr), (size))
-#define pestrdup(s, persistent)			strdup(s)
-
-#define pemalloc_rel(size, persistent)		malloc(size)
-#define pefree_rel(ptr, persistent)			free(ptr)
-#define pecalloc_rel(nmemb, size, persistent)		calloc((nmemb), (size))
-#define perealloc_rel(ptr, size, persistent)		realloc((ptr), (size))
-#define perealloc_recoverable_rel(ptr, size, persistent)	realloc((ptr), (size))
-#define pestrdup_rel(s, persistent)			strdup(s)
-
-#define safe_estrdup(ptr)  ((ptr)?(strdup(ptr)):(empty_string))
-#define safe_estrndup(ptr, len) ((ptr)?(strndup((ptr), (len))):(empty_string))
-
-#endif
+#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(TSRMLS_D);
-ZEND_API void shutdown_memory_manager(int silent, int full_shutdown TSRMLS_DC);
+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);
@@ -191,6 +123,7 @@ void zend_debug_alloc_output(char *format, ...);
 #define full_mem_check(silent)
 #endif
 
+
 END_EXTERN_C()
 
 #endif
@@ -199,6 +132,5 @@ END_EXTERN_C()
  * Local variables:
  * tab-width: 4
  * c-basic-offset: 4
- * indent-tabs-mode: t
  * End:
  */

Zend/zend_arg_defs.c

@@ -1,27 +0,0 @@
-ZEND_BEGIN_ARG_INFO(first_arg_force_ref, 0)
-	ZEND_ARG_PASS_INFO(1)
-ZEND_END_ARG_INFO();
-
-
-ZEND_BEGIN_ARG_INFO(second_arg_force_ref, 0)
-	ZEND_ARG_PASS_INFO(0)
-	ZEND_ARG_PASS_INFO(1)
-ZEND_END_ARG_INFO();
-
-ZEND_BEGIN_ARG_INFO(third_arg_force_ref, 0)
-	ZEND_ARG_PASS_INFO(0)
-	ZEND_ARG_PASS_INFO(0)
-	ZEND_ARG_PASS_INFO(1)
-ZEND_END_ARG_INFO();
-
-
-ZEND_BEGIN_ARG_INFO(fourth_arg_force_ref, 0)
-	ZEND_ARG_PASS_INFO(0)
-	ZEND_ARG_PASS_INFO(0)
-	ZEND_ARG_PASS_INFO(0)
-	ZEND_ARG_PASS_INFO(1)
-ZEND_END_ARG_INFO();
-
-ZEND_BEGIN_ARG_INFO(all_args_by_ref, 1)
-ZEND_END_ARG_INFO();
-

Zend/zend_builtin_functions.h

@@ -2,12 +2,12 @@
    +----------------------------------------------------------------------+
    | Zend Engine                                                          |
    +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2004 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
    +----------------------------------------------------------------------+
-   | This source file is subject to version 2.00 of the Zend license,     |
+   | 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 through the world-wide-web at the following url:           |
-   | http://www.zend.com/license/2_00.txt.                                |
+   | 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.              |
@@ -17,23 +17,10 @@
    +----------------------------------------------------------------------+
 */
 
-/* $Id$ */
 
 #ifndef ZEND_BUILTIN_FUNCTIONS_H
 #define ZEND_BUILTIN_FUNCTIONS_H
 
-int zend_startup_builtin_functions(TSRMLS_D);
-
-BEGIN_EXTERN_C()
-ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last TSRMLS_DC);
-END_EXTERN_C()
+int zend_startup_builtin_functions(void);
 
 #endif /* ZEND_BUILTIN_FUNCTIONS_H */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * indent-tabs-mode: t
- * End:
- */

Zend/zend_compile.h

@@ -2,12 +2,12 @@
    +----------------------------------------------------------------------+
    | Zend Engine                                                          |
    +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2004 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
    +----------------------------------------------------------------------+
-   | This source file is subject to version 2.00 of the Zend license,     |
+   | 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 through the world-wide-web at the following url:           |
-   | http://www.zend.com/license/2_00.txt.                                |
+   | 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.              |
@@ -17,7 +17,6 @@
    +----------------------------------------------------------------------+
 */
 
-/* $Id$ */
 
 #ifndef ZEND_COMPILE_H
 #define ZEND_COMPILE_H
@@ -28,26 +27,35 @@
 # 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
 
-#define INC_BPC(op_array)	if (CG(interactive)) { ((op_array)->backpatch_count++); }
-#define DEC_BPC(op_array)	if (CG(interactive)) { ((op_array)->backpatch_count--); }
-#define HANDLE_INTERACTIVE()  if (CG(interactive)) { execute_new_code(TSRMLS_C); }
-
-#define RESET_DOC_COMMENT()      \
-    {                            \
-        CG(doc_comment) = NULL;  \
-        CG(doc_comment_len) = 0; \
-    }
+#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 _zend_op zend_op;
 
 typedef struct _znode {
 	int op_type;
@@ -56,8 +64,8 @@ typedef struct _znode {
 
 		zend_uint var;
 		zend_uint opline_num; /*  Needs to be signed */
+		zend_uint fetch_type;
 		zend_op_array *op_array;
-		zend_op *jmp_addr;
 		struct {
 			zend_uint var;	/* dummy */
 			zend_uint type;
@@ -65,24 +73,15 @@ typedef struct _znode {
 	} u;
 } znode;
 
-typedef struct _zend_execute_data zend_execute_data;
 
-#define ZEND_OPCODE_HANDLER_ARGS zend_execute_data *execute_data TSRMLS_DC
-#define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU execute_data TSRMLS_CC
-
-typedef int (*opcode_handler_t) (ZEND_OPCODE_HANDLER_ARGS);
-
-extern ZEND_API opcode_handler_t zend_opcode_handlers[512];
-
-struct _zend_op {
-	opcode_handler_t handler;
+typedef struct _zend_op {
+	zend_uchar opcode;
 	znode result;
 	znode op1;
 	znode op2;
 	ulong extended_value;
 	uint lineno;
-	zend_uchar opcode;
-};
+} zend_op;
 
 
 typedef struct _zend_brk_cont_element {
@@ -92,79 +91,11 @@ typedef struct _zend_brk_cont_element {
 } zend_brk_cont_element;
 
 
-typedef struct _zend_try_catch_element {
-	zend_uint try_op;
-	zend_uint catch_op;  /* ketchup! */
-} zend_try_catch_element;
-
-
-/* method flags (types) */
-#define ZEND_ACC_STATIC			0x01
-#define ZEND_ACC_ABSTRACT		0x02
-#define ZEND_ACC_FINAL			0x04
-#define ZEND_ACC_IMPLEMENTED_ABSTRACT		0x08
-
-/* class flags (types) */
-/* ZEND_ACC_IMPLICIT_ABSTRACT_CLASS is used for abstract classes (since it is set by any abstract method even interfaces MAY have it set, too). */
-/* ZEND_ACC_EXPLICIT_ABSTRACT_CLASS denotes that a class was explicitly defined as abstract by using the keyword. */
-#define ZEND_ACC_IMPLICIT_ABSTRACT_CLASS	0x10
-#define ZEND_ACC_EXPLICIT_ABSTRACT_CLASS	0x20
-#define ZEND_ACC_FINAL_CLASS	            0x40
-#define ZEND_ACC_INTERFACE		            0x80
-
-/* method flags (visibility) */
-/* The order of those must be kept - public < protected < private */
-#define ZEND_ACC_PUBLIC		0x100
-#define ZEND_ACC_PROTECTED	0x200
-#define ZEND_ACC_PRIVATE	0x400
-#define ZEND_ACC_PPP_MASK  (ZEND_ACC_PUBLIC | ZEND_ACC_PROTECTED | ZEND_ACC_PRIVATE)
-
-#define ZEND_ACC_CHANGED	0x800
-#define ZEND_ACC_IMPLICIT_PUBLIC	0x1000
-
-/* method flags (special method detection) */
-#define ZEND_ACC_CTOR		0x2000
-#define ZEND_ACC_DTOR		0x4000
-#define ZEND_ACC_CLONE		0x8000
-
-/* method flag (bc only), any method that has this flag can be used statically and non statically. */
-#define ZEND_ACC_ALLOW_STATIC	0x10000
-
-char *zend_visibility_string(zend_uint fn_flags);
-
-
-typedef struct _zend_property_info {
-	zend_uint flags;
-	char *name;
-	int name_length;
-	ulong h;
-} zend_property_info;
-
-
-typedef struct _zend_arg_info {
-	char *name;
-	zend_uint name_len;
-	char *class_name;
-	zend_uint class_name_len;
-	zend_bool allow_null;
-	zend_bool pass_by_reference;
-	zend_bool return_reference;
-	int required_num_args;
-} zend_arg_info;
-
 struct _zend_op_array {
-	/* Common elements */
-	zend_uchar type;
-	char *function_name;		
-	zend_class_entry *scope;
-	zend_uint fn_flags;
-	union _zend_function *prototype;
-	zend_uint num_args;
-	zend_uint required_num_args;
-	zend_arg_info *arg_info;
-	zend_bool pass_rest_by_reference;
-	unsigned char return_reference;
-	/* END of common elements */
+	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;
 
@@ -176,70 +107,56 @@ struct _zend_op_array {
 	zend_brk_cont_element *brk_cont_array;
 	zend_uint last_brk_cont;
 	zend_uint current_brk_cont;
-
-	zend_try_catch_element *try_catch_array;
-	int last_try_catch;
+	zend_bool uses_globals;
 
 	/* static variables support */
 	HashTable *static_variables;
 
-	zend_op *start_op;
+#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;
-	zend_bool uses_this;
 
 	char *filename;
-	zend_uint line_start;
-	zend_uint line_end;
-	char *doc_comment;
-	zend_uint doc_comment_len;
 
 	void *reserved[ZEND_MAX_RESERVED_RESOURCES];
 };
 
 
-#define ZEND_RETURN_VALUE				0
-#define ZEND_RETURN_REFERENCE			1
-#define ZEND_RETURN_REFERENCE_AGNOSTIC	2
-
 typedef struct _zend_internal_function {
-	/* Common elements */
-	zend_uchar type;
-	char *function_name;		
-	zend_class_entry *scope;
-	zend_uint fn_flags;	
-	union _zend_function *prototype;
-	zend_uint num_args;
-	zend_uint required_num_args;
-	zend_arg_info *arg_info;
-	zend_bool pass_rest_by_reference;
-	unsigned char return_reference;
-	/* END of common elements */
+	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;
 
-#define ZEND_FN_SCOPE_NAME(function)  ((function) && (function)->common.scope ? (function)->common.scope->name : "")
+
+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;
-		zend_class_entry *scope;
-		zend_uint fn_flags;
-		union _zend_function *prototype;
-		zend_uint num_args;
-		zend_uint required_num_args;
-		zend_arg_info *arg_info;
-		zend_bool pass_rest_by_reference;
-		unsigned char return_reference;
 	} common;
 	
 	zend_op_array op_array;
 	zend_internal_function internal_function;
+	zend_overloaded_function overloaded_function;
 } zend_function;
 
 
@@ -263,22 +180,21 @@ typedef struct _list_llist_element {
 	znode value;
 } list_llist_element;
 
-union _temp_variable;
 
-struct _zend_execute_data {
-	struct _zend_op *opline;
-	zend_function_state function_state;
-	zend_function *fbc; /* Function Being Called */
-	zend_function *fbc_constructor;
-	zend_op_array *op_array;
-	zval *object;
-	union _temp_variable *Ts;
-	zend_bool original_in_execution;
-	zend_class_entry *calling_scope;
-	struct _zend_execute_data *prev_execute_data;
-};
+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 EX(element) execute_data.element
 
 
 #define IS_CONST	(1<<0)
@@ -286,254 +202,208 @@ struct _zend_execute_data {
 #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(TSRMLS_D);
-void shutdown_compiler(TSRMLS_D);
-void zend_init_compiler_data_structures(TSRMLS_D);
+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 TSRMLS_DC);
+extern ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type CLS_DC);
 
-ZEND_API int lex_scan(zval *zendlval TSRMLS_DC);
-void startup_scanner(TSRMLS_D);
-void shutdown_scanner(TSRMLS_D);
+void zend_activate(CLS_D ELS_DC);
+void zend_deactivate(CLS_D ELS_DC);
+void zend_activate_modules(void);
+void zend_deactivate_modules(void);
 
-ZEND_API char *zend_set_compiled_filename(char *new_compiled_filename TSRMLS_DC);
-ZEND_API void zend_restore_compiled_filename(char *original_compiled_filename TSRMLS_DC);
-ZEND_API char *zend_get_compiled_filename(TSRMLS_D);
-ZEND_API int zend_get_compiled_lineno(TSRMLS_D);
+
+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(TSRMLS_D);
-int zend_get_zendleng(TSRMLS_D);
+const char *zend_get_zendtext(CLS_D);
+int zend_get_zendleng(CLS_D);
 #endif
 
 
 /* parser-driven code generators */
-void zend_do_binary_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC);
-void zend_do_unary_op(zend_uchar op, znode *result, znode *op1 TSRMLS_DC);
-void zend_do_binary_assign_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC);
-void zend_do_assign(znode *result, znode *variable, znode *value TSRMLS_DC);
-void zend_do_assign_ref(znode *result, znode *lvar, znode *rvar TSRMLS_DC);
-void fetch_simple_variable(znode *result, znode *varname, int bp TSRMLS_DC);
-void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar op TSRMLS_DC);
-void zend_do_indirect_references(znode *result, znode *num_references, znode *variable TSRMLS_DC);
-void zend_do_fetch_static_variable(znode *varname, znode *static_assignment, int fetch_type TSRMLS_DC);
-void zend_do_fetch_global_variable(znode *varname, znode *static_assignment, int fetch_type TSRMLS_DC);
+void do_binary_op(int op, znode *result, znode *op1, znode *op2 CLS_DC);
+void do_unary_op(int op, znode *result, znode *op1 CLS_DC);
+void do_binary_assign_op(int op, znode *result, znode *op1, znode *op2 CLS_DC);
+void do_assign(znode *result, znode *variable, znode *value CLS_DC);
+void 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 do_indirect_references(znode *result, znode *num_references, znode *variable CLS_DC);
+void do_fetch_global_or_static_variable(znode *varname, znode *static_assignment, int fetch_type CLS_DC);
+void do_fetch_globals(znode *varname CLS_DC);
 
-void fetch_array_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC);
-void fetch_array_dim(znode *result, znode *parent, znode *dim TSRMLS_DC);
-void fetch_string_offset(znode *result, znode *parent, znode *offset TSRMLS_DC);
-void zend_do_fetch_static_member(znode *class_znode TSRMLS_DC);
-void zend_do_print(znode *result, znode *arg TSRMLS_DC);
-void zend_do_echo(znode *arg TSRMLS_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 do_print(znode *result, znode *arg CLS_DC);
+void 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 TSRMLS_DC);
-void zend_do_while_end(znode *while_token, znode *close_bracket_token TSRMLS_DC);
-void zend_do_do_while_begin(TSRMLS_D);
-void zend_do_do_while_end(znode *do_token, znode *expr_open_bracket, znode *expr TSRMLS_DC);
+void do_while_cond(znode *expr, znode *close_bracket_token CLS_DC);
+void do_while_end(znode *while_token, znode *close_bracket_token CLS_DC);
+void do_do_while_begin(CLS_D);
+void 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 TSRMLS_DC);
-void zend_do_if_after_statement(znode *closing_bracket_token, unsigned char initialize TSRMLS_DC);
-void zend_do_if_end(TSRMLS_D);
+void do_if_cond(znode *cond, znode *closing_bracket_token CLS_DC);
+void do_if_after_statement(znode *closing_bracket_token, unsigned char initialize CLS_DC);
+void do_if_end(CLS_D);
 
-void zend_do_for_cond(znode *expr, znode *second_semicolon_token TSRMLS_DC);
-void zend_do_for_before_statement(znode *cond_start, znode *second_semicolon_token TSRMLS_DC);
-void zend_do_for_end(znode *second_semicolon_token TSRMLS_DC);
+void do_for_cond(znode *expr, znode *second_semicolon_token CLS_DC);
+void do_for_before_statement(znode *cond_start, znode *second_semicolon_token CLS_DC);
+void do_for_end(znode *second_semicolon_token CLS_DC);
 
-void zend_do_pre_incdec(znode *result, znode *op1, zend_uchar op TSRMLS_DC);
-void zend_do_post_incdec(znode *result, znode *op1, zend_uchar op TSRMLS_DC);
+void do_pre_incdec(znode *result, znode *op1, int op CLS_DC);
+void do_post_incdec(znode *result, znode *op1, int op CLS_DC);
 
-void zend_do_begin_variable_parse(TSRMLS_D);
-void zend_do_end_variable_parse(int type, int arg_offset TSRMLS_DC);
+void do_begin_variable_parse(CLS_D);
+void do_end_variable_parse(int type, int arg_offset CLS_DC);
 
-void zend_check_writable_variable(znode *variable);
+void do_free(znode *op1 CLS_DC);
 
-void zend_do_free(znode *op1 TSRMLS_DC);
+void do_init_string(znode *result CLS_DC);
+void do_add_char(znode *result, znode *op1, znode *op2 CLS_DC);
+void do_add_string(znode *result, znode *op1, znode *op2 CLS_DC);
+void do_add_variable(znode *result, znode *op1, znode *op2 CLS_DC);
 
-void zend_do_init_string(znode *result TSRMLS_DC);
-void zend_do_add_char(znode *result, znode *op1, znode *op2 TSRMLS_DC);
-void zend_do_add_string(znode *result, znode *op1, znode *op2 TSRMLS_DC);
-void zend_do_add_variable(znode *result, znode *op1, znode *op2 TSRMLS_DC);
+void do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference CLS_DC);
+void do_end_function_declaration(znode *function_token CLS_DC);
+void do_receive_arg(int op, znode *var, znode *offset, znode *initialization, unsigned char pass_type CLS_DC);
+int do_begin_function_call(znode *function_name CLS_DC);
+void do_begin_dynamic_function_call(znode *function_name CLS_DC);
+void do_begin_class_member_function_call(znode *class_name, znode *function_name CLS_DC);
+void do_end_function_call(znode *function_name, znode *result, znode *argument_list, int is_method, int is_dynamic_fcall CLS_DC);
+void 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 do_inheritance(zend_class_entry *ce, zend_class_entry *parent_ce);
+void do_early_binding(CLS_D);
 
-int zend_do_verify_access_types(znode *current_access_type, znode *new_modifier);
-void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference, znode *fn_flags_znode TSRMLS_DC);
-void zend_do_end_function_declaration(znode *function_token TSRMLS_DC);
-void zend_do_receive_arg(zend_uchar op, znode *var, znode *offset, znode *initialization, znode *class_type, znode *varname, zend_bool pass_by_reference TSRMLS_DC);
-int zend_do_begin_function_call(znode *function_name TSRMLS_DC);
-void zend_do_begin_method_call(znode *left_bracket TSRMLS_DC);
-void zend_do_clone(znode *result, znode *expr TSRMLS_DC);
-void zend_do_begin_dynamic_function_call(znode *function_name TSRMLS_DC);
-void zend_do_fetch_class(znode *result, znode *class_name TSRMLS_DC);
-void zend_do_fetch_class_name(znode *result, znode *class_entry, znode *class_name TSRMLS_DC);
-void zend_do_begin_class_member_function_call(TSRMLS_D);
-void zend_do_end_function_call(znode *function_name, znode *result, znode *argument_list, int is_method, int is_dynamic_fcall TSRMLS_DC);
-void zend_do_return(znode *expr, int do_end_vparse TSRMLS_DC);
-void zend_do_handle_exception(TSRMLS_D);
-
-void zend_do_try(znode *try_token TSRMLS_DC);
-void zend_do_begin_catch(znode *try_token, znode *catch_class, znode *catch_var, zend_bool first_catch TSRMLS_DC);
-void zend_do_end_catch(znode *try_token TSRMLS_DC);
-void zend_do_throw(znode *expr TSRMLS_DC);
-
-ZEND_API int do_bind_function(zend_op *opline, HashTable *function_table, zend_bool compile_time);
-ZEND_API zend_class_entry *do_bind_class(zend_op *opline, HashTable *class_table, zend_bool compile_time TSRMLS_DC);
-ZEND_API zend_class_entry *do_bind_inherited_class(zend_op *opline, HashTable *class_table, zend_class_entry *parent_ce, zend_bool compile_time TSRMLS_DC);
-ZEND_API void zend_do_inherit_interfaces(zend_class_entry *ce, zend_class_entry *iface TSRMLS_DC);
-ZEND_API void zend_do_implement_interface(zend_class_entry *ce, zend_class_entry *iface TSRMLS_DC);
-void zend_do_implements_interface(znode *interface_znode TSRMLS_DC);
-
-void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent_ce TSRMLS_DC);
-void zend_do_early_binding(TSRMLS_D);
-
-void zend_do_pass_param(znode *param, zend_uchar op, int offset TSRMLS_DC);
+void do_pass_param(znode *param, int op, int offset CLS_DC);
 
 
-void zend_do_boolean_or_begin(znode *expr1, znode *op_token TSRMLS_DC);
-void zend_do_boolean_or_end(znode *result, znode *expr1, znode *expr2, znode *op_token TSRMLS_DC);
-void zend_do_boolean_and_begin(znode *expr1, znode *op_token TSRMLS_DC);
-void zend_do_boolean_and_end(znode *result, znode *expr1, znode *expr2, znode *op_token TSRMLS_DC);
+void do_boolean_or_begin(znode *expr1, znode *op_token CLS_DC);
+void do_boolean_or_end(znode *result, znode *expr1, znode *expr2, znode *op_token CLS_DC);
+void do_boolean_and_begin(znode *expr1, znode *op_token CLS_DC);               
+void do_boolean_and_end(znode *result, znode *expr1, znode *expr2, znode *op_token CLS_DC);
 
-void zend_do_brk_cont(zend_uchar op, znode *expr TSRMLS_DC);
+void do_brk_cont(int op, znode *expr CLS_DC);
 
-void zend_do_switch_cond(znode *cond TSRMLS_DC);
-void zend_do_switch_end(znode *case_list TSRMLS_DC);
-void zend_do_case_before_statement(znode *case_list, znode *case_token, znode *case_expr TSRMLS_DC);
-void zend_do_case_after_statement(znode *result, znode *case_token TSRMLS_DC);
-void zend_do_default_before_statement(znode *case_list, znode *default_token TSRMLS_DC);
+void do_switch_cond(znode *cond CLS_DC);
+void do_switch_end(znode *case_list CLS_DC);
+void do_case_before_statement(znode *case_list, znode *case_token, znode *case_expr CLS_DC);
+void do_case_after_statement(znode *result, znode *case_token CLS_DC);
+void do_default_before_statement(znode *case_list, znode *default_token CLS_DC);
 
-void zend_do_begin_class_declaration(znode *class_token, znode *class_name, znode *parent_class_name TSRMLS_DC);
-void zend_do_end_class_declaration(znode *class_token, znode *parent_token TSRMLS_DC);
-void zend_do_declare_property(znode *var_name, znode *value, zend_uint access_type TSRMLS_DC);
-void zend_do_declare_implicit_property(TSRMLS_D);
-void zend_do_declare_class_constant(znode *var_name, znode *value TSRMLS_DC);
+void do_begin_class_declaration(znode *class_name, znode *parent_class_name CLS_DC);
+void do_end_class_declaration(CLS_D);
+void do_declare_property(znode *var_name, znode *value CLS_DC);
 
-void zend_do_fetch_property(znode *result, znode *object, znode *property TSRMLS_DC);
+void do_fetch_property(znode *result, znode *object, znode *property CLS_DC);
 
 
-void zend_do_push_object(znode *object TSRMLS_DC);
-void zend_do_pop_object(znode *object TSRMLS_DC);
+void do_push_object(znode *object CLS_DC);
+void do_pop_object(znode *object CLS_DC);
 
 
-void zend_do_begin_new_object(znode *new_token, znode *class_type TSRMLS_DC);
-void zend_do_end_new_object(znode *result, znode *new_token, znode *argument_list TSRMLS_DC);
+void do_begin_new_object(znode *new_token, znode *class_name CLS_DC);
+void 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_container, znode *constant_name, int mode TSRMLS_DC);
+void do_fetch_constant(znode *result, znode *constant_name, int mode CLS_DC);
 
-void zend_do_shell_exec(znode *result, znode *cmd TSRMLS_DC);
+void do_shell_exec(znode *result, znode *cmd CLS_DC);
 
-void zend_do_init_array(znode *result, znode *expr, znode *offset, zend_bool is_ref TSRMLS_DC);
-void zend_do_add_array_element(znode *result, znode *expr, znode *offset, zend_bool is_ref TSRMLS_DC);
-void zend_do_add_static_array_element(znode *result, znode *offset, znode *expr);
-void zend_do_list_init(TSRMLS_D);
-void zend_do_list_end(znode *result, znode *expr TSRMLS_DC);
-void zend_do_add_list_element(znode *element TSRMLS_DC);
-void zend_do_new_list_begin(TSRMLS_D);
-void zend_do_new_list_end(TSRMLS_D);
+void do_init_array(znode *result, znode *expr, znode *offset, int is_ref CLS_DC);
+void do_add_array_element(znode *result, znode *expr, znode *offset, int is_ref CLS_DC);
+void do_add_static_array_element(znode *result, znode *offset, znode *expr);
+void do_list_init(CLS_D);
+void do_list_end(znode *result, znode *expr CLS_DC);
+void do_add_list_element(znode *element CLS_DC);
+void do_new_list_begin(CLS_D);
+void do_new_list_end(CLS_D);
 
-void zend_do_cast(znode *result, znode *expr, int type TSRMLS_DC);
-void zend_do_include_or_eval(int type, znode *result, znode *op1 TSRMLS_DC);
+void do_cast(znode *result, znode *expr, int type CLS_DC);
+void do_include_or_eval(int type, znode *result, znode *op1 CLS_DC);
 
-void zend_do_unset(znode *variable TSRMLS_DC);
-void zend_do_isset_or_isempty(int type, znode *result, znode *variable TSRMLS_DC);
+void do_unset(znode *variable CLS_DC);
+void do_isset_or_isempty(int type, znode *result, znode *variable CLS_DC);
 
-void zend_do_instanceof(znode *result, znode *expr, znode *class_znode, int type TSRMLS_DC);
+void do_foreach_begin(znode *foreach_token, znode *array, znode *open_brackets_token, znode *as_token, int variable CLS_DC);
+void do_foreach_cont(znode *value, znode *key, znode *as_token CLS_DC);
+void do_foreach_end(znode *foreach_token, znode *open_brackets_token CLS_DC);
 
-void zend_do_foreach_begin(znode *foreach_token, znode *array, znode *open_brackets_token, znode *as_token, int variable TSRMLS_DC);
-void zend_do_foreach_cont(znode *value, znode *key, znode *as_token, znode *foreach_token TSRMLS_DC);
-void zend_do_foreach_end(znode *foreach_token, znode *open_brackets_token TSRMLS_DC);
+void do_declare_begin(CLS_D);
+void do_declare_stmt(znode *var, znode *val CLS_DC);
+void do_declare_end(CLS_D);
 
-void zend_do_declare_begin(TSRMLS_D);
-void zend_do_declare_stmt(znode *var, znode *val TSRMLS_DC);
-void zend_do_declare_end(znode *declare_token TSRMLS_DC);
+void do_end_heredoc(CLS_D);
 
-void zend_do_end_heredoc(TSRMLS_D);
+void do_exit(znode *result, znode *message CLS_DC);
 
-void zend_do_exit(znode *result, znode *message TSRMLS_DC);
+void do_begin_silence(znode *strudel_token CLS_DC);
+void do_end_silence(znode *strudel_token CLS_DC);
 
-void zend_do_begin_silence(znode *strudel_token TSRMLS_DC);
-void zend_do_end_silence(znode *strudel_token TSRMLS_DC);
+void do_begin_qm_op(znode *cond, znode *qm_token CLS_DC);
+void do_qm_true(znode *true_value, znode *qm_token, znode *colon_token CLS_DC);
+void do_qm_false(znode *result, znode *false_value, znode *qm_token, znode *colon_token CLS_DC);
 
-void zend_do_begin_qm_op(znode *cond, znode *qm_token TSRMLS_DC);
-void zend_do_qm_true(znode *true_value, znode *qm_token, znode *colon_token TSRMLS_DC);
-void zend_do_qm_false(znode *result, znode *false_value, znode *qm_token, znode *colon_token TSRMLS_DC);
+void do_extended_info(CLS_D);
+void do_extended_fcall_begin(CLS_D);
+void do_extended_fcall_end(CLS_D);
 
-void zend_do_extended_info(TSRMLS_D);
-void zend_do_extended_fcall_begin(TSRMLS_D);
-void zend_do_extended_fcall_end(TSRMLS_D);
-
-void zend_do_ticks(TSRMLS_D);
-
-void zend_do_abstract_method(znode *function_name, znode *modifiers, znode *body TSRMLS_DC);
+void 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 TSRMLS_DC);
-ZEND_API zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC);	
-ZEND_API zend_op_array *compile_filename(int type, zval *filename TSRMLS_DC);
-ZEND_API int zend_execute_scripts(int type TSRMLS_DC, zval **retval, int file_count, ...);
-ZEND_API int open_file_for_scanning(zend_file_handle *file_handle TSRMLS_DC);
-ZEND_API void init_op_array(zend_op_array *op_array, zend_uchar type, int initial_ops_size TSRMLS_DC);
-ZEND_API void destroy_op_array(zend_op_array *op_array TSRMLS_DC);
-ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle TSRMLS_DC);
+/* helper functions in zend-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 int zend_cleanup_class_data(zend_class_entry **pce TSRMLS_DC);
-ZEND_API int zend_cleanup_function_data(zend_function *function TSRMLS_DC);
 
-ZEND_API void destroy_zend_function(zend_function *function TSRMLS_DC);
-ZEND_API void zend_function_dtor(zend_function *function);
-ZEND_API void destroy_zend_class(zend_class_entry **pce);
-void zend_class_add_ref(zend_class_entry **ce);
+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);
 
-ZEND_API void zend_mangle_property_name(char **dest, int *dest_length, char *src1, int src1_length, char *src2, int src2_length, int internal);
-ZEND_API void zend_unmangle_property_name(char *mangled_property, char **prop_name, char **class_name);
-
-#define ZEND_FUNCTION_DTOR (void (*)(void *)) zend_function_dtor
+#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 TSRMLS_DC);
-void init_op(zend_op *op TSRMLS_DC);
+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 TSRMLS_DC);
+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 TSRMLS_DC);
+int pass_two(zend_op_array *op_array);
 zend_brk_cont_element *get_next_brk_cont_element(zend_op_array *op_array);
-void zend_do_first_catch(znode *open_parentheses TSRMLS_DC);
-void zend_initialize_try_catch_element(znode *try_token TSRMLS_DC);
-void zend_do_mark_last_catch(znode *first_catch, znode *last_additional_catch TSRMLS_DC);
-ZEND_API zend_bool zend_is_compiling(TSRMLS_D);
-ZEND_API char *zend_make_compiled_string_description(char *name TSRMLS_DC);
-ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify_handlers TSRMLS_DC);
-int zend_get_class_fetch_type(char *class_name, uint class_name_len);
+ZEND_API zend_bool zend_is_compiling(void);
+ZEND_API char *zend_make_compiled_string_description(char *name);
 
-typedef zend_bool (*zend_auto_global_callback)(char *name, uint name_len TSRMLS_DC);
-typedef struct _zend_auto_global {
-	char *name;
-	uint name_len;
-	zend_auto_global_callback auto_global_callback;
-	zend_bool armed;
-} zend_auto_global;
+int zendlex(znode *zendlval CLS_DC);
 
-void zend_auto_global_dtor(zend_auto_global *auto_global);
-ZEND_API int zend_register_auto_global(char *name, uint name_len, zend_auto_global_callback auto_global_callback TSRMLS_DC);
-ZEND_API zend_bool zend_is_auto_global(char *name, uint name_len TSRMLS_DC);
-ZEND_API int zend_auto_global_disable_jit(char *varname, zend_uint varname_length TSRMLS_DC);
-
-int zendlex(znode *zendlval TSRMLS_DC);
-
-/* BEGIN: OPCODES */
 #define ZEND_NOP					0
 									
 #define ZEND_ADD					1
@@ -625,6 +495,7 @@ int zendlex(znode *zendlval TSRMLS_DC);
 									
 #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
@@ -657,7 +528,7 @@ int zendlex(znode *zendlval TSRMLS_DC);
 #define ZEND_FETCH_DIM_TMP_VAR		98
 #define ZEND_FETCH_CONSTANT			99
 
-/* Hole - 100 */
+#define ZEND_DECLARE_FUNCTION_OR_CLASS	100
 
 #define ZEND_EXT_STMT				101
 #define ZEND_EXT_FCALL_BEGIN		102
@@ -666,90 +537,15 @@ int zendlex(znode *zendlval TSRMLS_DC);
 
 #define ZEND_TICKS					105
 
-#define ZEND_SEND_VAR_NO_REF		106
-
-#define ZEND_CATCH					107
-#define ZEND_THROW					108
-
-#define ZEND_FETCH_CLASS			109
-
-#define ZEND_CLONE					110
-
-#define ZEND_INIT_CTOR_CALL			111
-#define ZEND_INIT_METHOD_CALL		112
-#define ZEND_INIT_STATIC_METHOD_CALL 113
-
-#define ZEND_ISSET_ISEMPTY_VAR		114
-#define ZEND_ISSET_ISEMPTY_DIM_OBJ	115
-
-#define	ZEND_IMPORT_FUNCTION		116
-#define	ZEND_IMPORT_CLASS			117
-#define	ZEND_IMPORT_CONST			118
-									
-#define ZEND_PRE_INC_OBJ			132
-#define ZEND_PRE_DEC_OBJ			133
-#define ZEND_POST_INC_OBJ			134
-#define ZEND_POST_DEC_OBJ			135
-								 	
-#define ZEND_ASSIGN_OBJ				136
-#define ZEND_OP_DATA				137
-
-#define ZEND_INSTANCEOF				138
-
-#define ZEND_DECLARE_CLASS				139
-#define ZEND_DECLARE_INHERITED_CLASS	140
-#define ZEND_DECLARE_FUNCTION			141
-
-#define ZEND_RAISE_ABSTRACT_ERROR	142
-
-
-
-#define ZEND_ADD_INTERFACE			144
-#define ZEND_VERIFY_ABSTRACT_CLASS	146
-
-#define ZEND_ASSIGN_DIM				147
-
-#define ZEND_ISSET_ISEMPTY_PROP_OBJ	148
-
-#define ZEND_HANDLE_EXCEPTION		149
-
 /* end of block */
-/* END: OPCODES */
 
 
 
 
 /* global/local fetches */
-#define ZEND_FETCH_GLOBAL			0
-#define ZEND_FETCH_LOCAL			1
-#define ZEND_FETCH_STATIC			2
-#define ZEND_FETCH_STATIC_MEMBER	3
-
-
-/* obj/dim unsets */
-#define ZEND_UNSET_DIM				1
-#define ZEND_UNSET_OBJ				2
-
-/* class fetches */
-#define ZEND_FETCH_CLASS_DEFAULT	0
-#define ZEND_FETCH_CLASS_SELF		1
-#define ZEND_FETCH_CLASS_PARENT		2
-#define ZEND_FETCH_CLASS_MAIN		3
-#define ZEND_FETCH_CLASS_GLOBAL		4
-#define ZEND_FETCH_CLASS_AUTO		5
-
-
-/* variable parsing type (compile-time) */
-#define ZEND_PARSED_MEMBER				(1<<0)
-#define ZEND_PARSED_METHOD_CALL			(1<<1)
-#define ZEND_PARSED_STATIC_MEMBER		(1<<2)
-#define ZEND_PARSED_FUNCTION_CALL		(1<<3)
-#define ZEND_PARSED_VARIABLE			(1<<4)
-#define ZEND_PARSED_REFERENCE_VARIABLE	(1<<5)
-
-
-/* unset types */
-#define ZEND_UNSET_REG 0
+#define ZEND_FETCH_GLOBAL	0
+#define ZEND_FETCH_LOCAL	1
+#define ZEND_FETCH_STATIC	2
 
 /* var status for backpatching */
 #define BP_VAR_R			0
@@ -761,14 +557,13 @@ int zendlex(znode *zendlval TSRMLS_DC);
 #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_OVERLOADED_FUNCTION_TEMPORARY	5
+#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_INTERNAL_CLASS		1
+#define ZEND_USER_CLASS			2
 
 #define ZEND_EVAL				(1<<0)
 #define ZEND_INCLUDE			(1<<1)
@@ -788,60 +583,47 @@ int zendlex(znode *zendlval TSRMLS_DC);
 #define ZEND_HANDLE_FP				2
 #define ZEND_HANDLE_STDIOSTREAM		3
 #define ZEND_HANDLE_FSTREAM			4
-#define ZEND_HANDLE_STREAM			5
+
+#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_FE_FETCH_BYREF	1
-#define ZEND_FE_FETCH_WITH_KEY	2
-
 #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(zf, arg_num)											\
-	(																					\
-		zf																				\
-		&& ((zend_function *) zf)->common.arg_info										\
-		&&																				\
-		(																				\
-			(																			\
-				arg_num<=((zend_function *) zf)->common.num_args						\
-				&& ((zend_function *) zf)->common.arg_info[arg_num-1].pass_by_reference	\
-			)																			\
-		||	(																			\
-				arg_num>((zend_function *) zf)->common.num_args							\
-				&& ((zend_function *) zf)->common.pass_rest_by_reference				\
-			)																			\
-		)																				\
+#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
 
-
-#define ZEND_RETURNS_FUNCTION 1<<0
-
 END_EXTERN_C()
 
-#define ZEND_CLONE_FUNC_NAME		"__clone"
-#define ZEND_CONSTRUCTOR_FUNC_NAME	"__construct"
-#define ZEND_DESTRUCTOR_FUNC_NAME	"__destruct"
-#define ZEND_GET_FUNC_NAME          "__get"
-#define ZEND_SET_FUNC_NAME          "__set"
-#define ZEND_CALL_FUNC_NAME         "__call"
-#define ZEND_AUTOLOAD_FUNC_NAME     "__autoload"
-
 #endif /* ZEND_COMPILE_H */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * indent-tabs-mode: t
- * End:
- */

Zend/zend_config.nw.h

@@ -1,88 +0,0 @@
-/*
-   +----------------------------------------------------------------------+
-   | Zend Engine                                                          |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2004 Zend Technologies Ltd. (http://www.zend.com) |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 2.00 of the Zend license,     |
-   | that is bundled with this package in the file LICENSE, and is        | 
-   | available through the world-wide-web at the following url:           |
-   | http://www.zend.com/license/2_00.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>                                |
-   +----------------------------------------------------------------------+
-*/
-
-/* $Id$ */
-
-#ifndef ZEND_CONFIG_NW_H
-#define ZEND_CONFIG_NW_H
-
-
-#include <string.h>
-#include <float.h>
-
-typedef unsigned long ulong;
-typedef unsigned int uint;
-
-#define HAVE_ALLOCA 1
-#define HAVE_LIMITS_H 1
-/* #include <malloc.h> */
-
-#define HAVE_STRING_H 1
-
-#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_DLFCN_H	1
-/* #define HAVE_LIBDL 1 */
-#define HAVE_SNPRINTF	1
-#define HAVE_VSNPRINTF	1
-
-/*
-#define snprintf _snprintf
-#define vsnprintf _vsnprintf
-#define zend_isinf(a)	0
-#define zend_finite(x)	_finite(x)
-#define zend_isnan(x)	_isnan(x)
-*/
-
-#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)
-*/
-
-#endif /* ZEND_CONFIG_NW_H */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * indent-tabs-mode: t
- * End:
- */

Zend/zend_config.w32.h

@@ -2,12 +2,12 @@
    +----------------------------------------------------------------------+
    | Zend Engine                                                          |
    +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2004 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
    +----------------------------------------------------------------------+
-   | This source file is subject to version 2.00 of the Zend license,     |
+   | 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 through the world-wide-web at the following url:           |
-   | http://www.zend.com/license/2_00.txt.                                |
+   | 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.              |
@@ -17,32 +17,22 @@
    +----------------------------------------------------------------------+
 */
 
-/* $Id$ */
 
 #ifndef ZEND_CONFIG_W32_H
 #define ZEND_CONFIG_W32_H
 
-#define HAVE_ALLOCA 1
-#define HAVE_LIMITS_H 1
-#define _CRTDBG_MAP_ALLOC
-
-#include <malloc.h>
-#include <stdlib.h>
-#include <crtdbg.h>
 
 #include <string.h>
-
-#ifndef ZEND_INCLUDE_FULL_WINDOWS_HEADERS
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include <winsock2.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 */
@@ -56,13 +46,8 @@ typedef unsigned int uint;
 #define HAVE_SNPRINTF	1
 #define HAVE_VSNPRINTF	1
 
-#define snprintf _snprintf
 #define vsnprintf _vsnprintf
-#define strcasecmp(s1, s2) stricmp(s1, s2)
-#define strncasecmp(s1, s2, n) strnicmp(s1, s2, n)
-#define zend_isinf(a)	((_fpclass(a) == _FPCLASS_PINF) || (_fpclass(a) == _FPCLASS_NINF))
-#define zend_finite(x)	_finite(x)
-#define zend_isnan(x)	_isnan(x)
+#define zend_isinf(a)	0
 
 #define zend_sprintf sprintf
 
@@ -76,6 +61,9 @@ typedef unsigned int uint;
 # define inline
 #endif
 
+#define zend_finite(A) _finite(A)
+#define zend_isnan(A) _isnan(A)
+
 #ifdef LIBZEND_EXPORTS
 #	define ZEND_API __declspec(dllexport)
 #else
@@ -83,7 +71,6 @@ typedef unsigned int uint;
 #endif
 
 #define ZEND_DLEXPORT		__declspec(dllexport)
-#define ZEND_DLIMPORT		__declspec(dllimport)
 
 /* 0x00200000L is MB_SERVICE_NOTIFICATION, which is only supported under Windows NT 
  * (and requires _WIN32_WINNT to be defined, which prevents the resulting executable
@@ -97,11 +84,3 @@ typedef unsigned int uint;
 #define ZEND_SERVICE_MB_STYLE		(MB_TOPMOST|MB_SERVICE_NOTIFICATION)
 
 #endif /* ZEND_CONFIG_W32_H */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * indent-tabs-mode: t
- * End:
- */

Zend/zend_constants.c

@@ -2,12 +2,12 @@
    +----------------------------------------------------------------------+
    | Zend Engine                                                          |
    +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2004 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
    +----------------------------------------------------------------------+
-   | This source file is subject to version 2.00 of the Zend license,     |
+   | 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 through the world-wide-web at the following url:           |
-   | http://www.zend.com/license/2_00.txt.                                |
+   | 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.              |
@@ -17,11 +17,9 @@
    +----------------------------------------------------------------------+
 */
 
-/* $Id$ */
 
 #include "zend.h"
 #include "zend_constants.h"
-#include "zend_execute.h"
 #include "zend_variables.h"
 #include "zend_operators.h"
 #include "zend_globals.h"
@@ -38,7 +36,7 @@ void free_zend_constant(zend_constant *c)
 
 void copy_zend_constant(zend_constant *c)
 {
-	c->name = zend_strndup(c->name, c->name_len - 1);
+	c->name = zend_strndup(c->name, c->name_len);
 	if (!(c->flags & CONST_PERSISTENT)) {
 		zval_copy_ctor(&c->value);
 	}
@@ -53,17 +51,17 @@ void zend_copy_constants(HashTable *target, HashTable *source)
 }
 
 
-static int clean_non_persistent_constant(zend_constant *c TSRMLS_DC)
+static int clean_non_persistent_constant(zend_constant *c)
 {
 	if (c->flags & CONST_PERSISTENT) {
-		return EG(full_tables_cleanup) ? 0 : ZEND_HASH_APPLY_STOP;
+		return 0;
 	} else {
-		return EG(full_tables_cleanup) ? 1 : ZEND_HASH_APPLY_REMOVE;
+		return 1;
 	}
 }
 
 
-static int clean_module_constant(zend_constant *c, int *module_number TSRMLS_DC)
+static int clean_module_constant(zend_constant *c, int *module_number)
 {
 	if (c->module_number == *module_number) {
 		return 1;
@@ -73,14 +71,23 @@ static int clean_module_constant(zend_constant *c, int *module_number TSRMLS_DC)
 }
 
 
-void clean_module_constants(int module_number TSRMLS_DC)
+void clean_module_constants(int module_number)
 {
-	zend_hash_apply_with_argument(EG(zend_constants), (apply_func_arg_t) clean_module_constant, (void *) &module_number TSRMLS_CC);
+	ELS_FETCH();
+
+	zend_hash_apply_with_argument(EG(zend_constants), (int (*)(void *,void *)) clean_module_constant, (void *) &module_number);
 }
 
 
-int zend_startup_constants(TSRMLS_D)
+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) {
@@ -91,13 +98,12 @@ int zend_startup_constants(TSRMLS_D)
 
 
 
-void zend_register_standard_constants(TSRMLS_D)
+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_STRICT", E_STRICT, 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);
@@ -116,33 +122,33 @@ void zend_register_standard_constants(TSRMLS_D)
 		c.flags = CONST_PERSISTENT;
 		c.module_number = 0;
 
-		c.name = zend_strndup(ZEND_STRS("TRUE"));
+		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 TSRMLS_CC);
+		zend_register_constant(&c ELS_CC);
 		
-		c.name = zend_strndup(ZEND_STRS("FALSE"));
+		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 TSRMLS_CC);
+		zend_register_constant(&c ELS_CC);
 
-		c.name = zend_strndup(ZEND_STRS("ZEND_THREAD_SAFE"));
+		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 TSRMLS_CC);
+		zend_register_constant(&c ELS_CC);
 
-		c.name = zend_strndup(ZEND_STRS("NULL"));
+		c.name = zend_strndup(ZEND_STRL("NULL"));
 		c.name_len = sizeof("NULL");
 		c.value.type = IS_NULL;
-		zend_register_constant(&c TSRMLS_CC);
+		zend_register_constant(&c ELS_CC);
 	}
 }
 
 
-int zend_shutdown_constants(TSRMLS_D)
+int zend_shutdown_constants(ELS_D)
 {
 	zend_hash_destroy(EG(zend_constants));
 	free(EG(zend_constants));
@@ -150,45 +156,43 @@ int zend_shutdown_constants(TSRMLS_D)
 }
 
 
-void clean_non_persistent_constants(TSRMLS_D)
+void clean_non_persistent_constants(void)
 {
-	if (EG(full_tables_cleanup)) {
-		zend_hash_apply(EG(zend_constants), (apply_func_t) clean_non_persistent_constant TSRMLS_CC);
-	} else {
-		zend_hash_reverse_apply(EG(zend_constants), (apply_func_t) clean_non_persistent_constant TSRMLS_CC);
-	}
+	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 TSRMLS_DC)
+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-1);
+	c.name = zend_strndup(name,name_len);
 	c.name_len = name_len;
 	c.module_number = module_number;
-	zend_register_constant(&c TSRMLS_CC);
+	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 TSRMLS_DC)
+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-1);
+	c.name = zend_strndup(name,name_len);
 	c.name_len = name_len;
 	c.module_number = module_number;
-	zend_register_constant(&c TSRMLS_CC);
+	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 TSRMLS_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_constant c;
 	
@@ -196,137 +200,61 @@ ZEND_API void zend_register_stringl_constant(char *name, uint name_len, char *st
 	c.value.value.str.val = strval;
 	c.value.value.str.len = strlen;
 	c.flags = flags;
-	c.name = zend_strndup(name, name_len-1);
+	c.name = zend_strndup(name,name_len);
 	c.name_len = name_len;
 	c.module_number = module_number;
-	zend_register_constant(&c TSRMLS_CC);
+	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 TSRMLS_DC)
+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 TSRMLS_CC);
+	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 TSRMLS_DC)
+ZEND_API int zend_get_constant(char *name, uint name_len, zval *result)
 {
 	zend_constant *c;
-	int retval = 1;
-	char *lookup_name;
-	char *colon;
+	char *lookup_name = estrndup(name,name_len);
+	int retval;
+	ELS_FETCH();
 
-	if ((colon = memchr(name, ':', name_len)) && colon[1] == ':') {
-		/* class constant */
-		zend_class_entry **ce = NULL, *scope;
-		int class_name_len = colon-name;
-		int const_name_len = name_len - class_name_len - 2;
-		char *constant_name = colon+2;
-		zval **ret_constant;
-		char *class_name;
+	zend_str_tolower(lookup_name, name_len);
 
-		if (EG(in_execution)) {
-			scope = EG(scope);
+	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 {
-			scope = CG(active_class_entry);
-		}
-	
-		class_name = estrndup(name, class_name_len);
-
-		if (class_name_len == sizeof("self")-1 && strcmp(class_name, "self") == 0) {
-			if (scope) {
-				ce = &scope;
-			} else {
-				zend_error(E_ERROR, "Cannot access self:: when no class scope is active");
-				retval = 0;
-			}
-		} else if (class_name_len == sizeof("parent")-1 && strcmp(class_name, "parent") == 0) {
-			if (!scope) {   	 
-				zend_error(E_ERROR, "Cannot access parent:: when no class scope is active");
-			} else if (!scope->parent) { 	 
-				zend_error(E_ERROR, "Cannot access parent:: when current class scope has no parent"); 	 
-			} else {
-				ce = &scope->parent;
-			}
-		} else {
-			if (zend_lookup_class(class_name, class_name_len, &ce TSRMLS_CC) != SUCCESS) {
-				retval = 0;
-			}
-		}
-		efree(class_name);
-
-		if (retval && ce) {
-			if (zend_hash_find(&((*ce)->constants_table), constant_name, const_name_len+1, (void **) &ret_constant) != SUCCESS) {
-				retval = 0;
-			}
-		} else {
-			retval = 0;
-		}
-
-		if (retval) {
-			zval_update_constant(ret_constant, (void*)1 TSRMLS_CC);
-			*result = **ret_constant;
+			retval=1;
+			*result = c->value;
 			zval_copy_ctor(result);
 		}
-		
-		return retval;
+	} else {
+		retval=0;
 	}
 	
-	if (zend_hash_find(EG(zend_constants), name, name_len+1, (void **) &c) == FAILURE) {
-		lookup_name = estrndup(name, name_len);
-		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=0;
-		}
-		efree(lookup_name);
-	}
-
-	if (retval) {
-		*result = c->value;
-		zval_copy_ctor(result);
-		result->refcount = 1;
-		result->is_ref = 0;
-	}
-
+	efree(lookup_name);
 	return retval;
 }
 
 
-ZEND_API int zend_register_constant(zend_constant *c TSRMLS_DC)
+ZEND_API int zend_register_constant(zend_constant *c ELS_DC)
 {
-	char *lowercase_name = NULL;
-	char *name;
+	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);
+	printf("Registering constant for module %d\n",c->module_number);
 #endif
 
-	if (!(c->flags & CONST_CS)) {
-		/* keep in mind that c->name_len already contains the '\0' */
-		lowercase_name = estrndup(c->name, c->name_len);
-		zend_str_tolower(lowercase_name, c->name_len);
-		name = lowercase_name;
-	} else {
-		name = c->name;
-	}
-
-	if (zend_hash_add(EG(zend_constants), name, c->name_len, (void *) c, sizeof(zend_constant), NULL)==FAILURE) {
-		zend_error(E_NOTICE,"Constant %s already defined", name);
-		free(c->name);
-		if (!(c->flags & CONST_PERSISTENT)) {
-			zval_dtor(&c->value);
-		}
+	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;
 	}
-	if (lowercase_name) {
-		efree(lowercase_name);
-	}
+	free(lowercase_name);
 	return ret;
 }
 
@@ -335,6 +263,5 @@ ZEND_API int zend_register_constant(zend_constant *c TSRMLS_DC)
  * Local variables:
  * tab-width: 4
  * c-basic-offset: 4
- * indent-tabs-mode: t
  * End:
  */

Zend/zend_constants.h

@@ -2,12 +2,12 @@
    +----------------------------------------------------------------------+
    | Zend Engine                                                          |
    +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2004 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
    +----------------------------------------------------------------------+
-   | This source file is subject to version 2.00 of the Zend license,     |
+   | 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 through the world-wide-web at the following url:           |
-   | http://www.zend.com/license/2_00.txt.                                |
+   | 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.              |
@@ -17,17 +17,14 @@
    +----------------------------------------------------------------------+
 */
 
-/* $Id$ */
 
 #ifndef ZEND_CONSTANTS_H
 #define ZEND_CONSTANTS_H
 
 #include "zend_globals.h"
 
-#define CONST_CS				(1<<0)				/* Case Sensitive */
-#define CONST_PERSISTENT		(1<<1)				/* Persistent */
-
-#define	PHP_USER_CONSTANT INT_MAX	/* a constant defined in user space */
+#define CONST_CS 0x1				/* Case Sensitive */
+#define CONST_PERSISTENT 0x2
 
 typedef struct _zend_constant {
 	zval value;
@@ -37,41 +34,31 @@ typedef struct _zend_constant {
 	int module_number;
 } zend_constant;
 
-#define REGISTER_LONG_CONSTANT(name, lval, flags)  zend_register_long_constant((name), sizeof(name), (lval), (flags), module_number TSRMLS_CC)
-#define REGISTER_DOUBLE_CONSTANT(name, dval, flags)  zend_register_double_constant((name), sizeof(name), (dval), (flags), module_number TSRMLS_CC)
-#define REGISTER_STRING_CONSTANT(name, str, flags)  zend_register_string_constant((name), sizeof(name), (str), (flags), module_number TSRMLS_CC)
-#define REGISTER_STRINGL_CONSTANT(name, str, len, flags)  zend_register_stringl_constant((name), sizeof(name), (str), (len), (flags), module_number TSRMLS_CC)
+#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 TSRMLS_CC)
-#define REGISTER_MAIN_DOUBLE_CONSTANT(name, dval, flags)  zend_register_double_constant((name), sizeof(name), (dval), (flags), 0 TSRMLS_CC)
-#define REGISTER_MAIN_STRING_CONSTANT(name, str, flags)  zend_register_string_constant((name), sizeof(name), (str), (flags), 0 TSRMLS_CC)
-#define REGISTER_MAIN_STRINGL_CONSTANT(name, str, len, flags)  zend_register_stringl_constant((name), sizeof(name), (str), (len), (flags), 0 TSRMLS_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)
 
-BEGIN_EXTERN_C()
-void clean_module_constants(int module_number TSRMLS_DC);
+void clean_module_constants(int module_number);
 void free_zend_constant(zend_constant *c);
-int zend_startup_constants(TSRMLS_D);
-int zend_shutdown_constants(TSRMLS_D);
-void zend_register_standard_constants(TSRMLS_D);
-void clean_non_persistent_constants(TSRMLS_D);
-ZEND_API int zend_get_constant(char *name, uint name_len, zval *result TSRMLS_DC);
-ZEND_API void zend_register_long_constant(char *name, uint name_len, long lval, int flags, int module_number TSRMLS_DC);
-ZEND_API void zend_register_double_constant(char *name, uint name_len, double dval, int flags, int module_number TSRMLS_DC);
-ZEND_API void zend_register_string_constant(char *name, uint name_len, char *strval, int flags, int module_number TSRMLS_DC);
-ZEND_API void zend_register_stringl_constant(char *name, uint name_len, char *strval, uint strlen, int flags, int module_number TSRMLS_DC);
-ZEND_API int zend_register_constant(zend_constant *c TSRMLS_DC);
+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);
-END_EXTERN_C()
 
 #define ZEND_CONSTANT_DTOR (void (*)(void *)) free_zend_constant
 
 #endif
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * indent-tabs-mode: t
- * End:
- */

Zend/zend_default_classes.c

@@ -1,44 +0,0 @@
-/*
-   +----------------------------------------------------------------------+
-   | Zend Engine                                                          |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2004 Zend Technologies Ltd. (http://www.zend.com) |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 2.00 of the Zend license,     |
-   | that is bundled with this package in the file LICENSE, and is        |
-   | available through the world-wide-web at the following url:           |
-   | http://www.zend.com/license/2_00.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: Sterling Hughes <sterling@php.net>                          |
-   |          Marcus Boerger <helly@php.net>                              |
-   +----------------------------------------------------------------------+
-*/
-
-/* $Id$ */
-
-#include "zend.h"
-#include "zend_API.h"
-#include "zend_reflection_api.h"
-#include "zend_builtin_functions.h"
-#include "zend_interfaces.h"
-#include "zend_exceptions.h"
-
-
-ZEND_API void zend_register_default_classes(TSRMLS_D)
-{
-	zend_register_interfaces(TSRMLS_C);
-	zend_register_default_exception(TSRMLS_C);
-	zend_register_reflection_api(TSRMLS_C);
-	zend_register_iterator_wrapper(TSRMLS_C);
-}
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * indent-tabs-mode: t
- * End:
- */