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

2026-11-11 19:20:50 +00:00 · 1999-11-14 20:13:55 +00:00
1498 changed files with 46451 additions and 208100 deletions
@@ -5,9 +5,8 @@ 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.  Since we are now
-well into the version 4 releases, many sections have been recoded to use
-these rules.
+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
@@ -44,9 +43,9 @@ Exceptions:
    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())
+    recalculated with strlen() (e.g. _php3_addslashes())

-[5] Use php_error() to report any errors/warnings during code execution.
+[5] Use php3_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,
@@ -64,28 +63,12 @@ Exceptions:
 Naming Conventions
 ------------------

-[1] Function names for user functions should be enclosed with in
-    the PHP_FUNCTION() macro. They should be in lowercase, with words
-    underscore delimited, with care taken to minimize the letter count.
-    If they are part of a "parent set" of functions, that parent should
-    be included in the user function name.
+[1] Function names for user functions implementation should be prefixed with
+    "php3_", and followed by a word or an underscore-delimited list of words,
+    in lowercase letters, that describes the function.

-    Good:
-    'mcrypt_enc_self_test'
-    'mysql_list_fields'
-
-    Ok:
-    'mcrypt_module_get_algo_supported_key_sizes'
-    (could be 'mcrypt_mod_get_algo_sup_key_sizes'?)
-    'get_html_translation_table'
-    (could be 'html_get_trans_table'?) 
-
-    Bad:
-    'hw_GetObjectByQueryCollObj'
-    'pg_setclientencoding'
-
-[2] Function names used by user functions should be prefixed
-    with "_php_", and followed by a word or an underscore-delimited list of
+[2] Function names used by user functions implementations should be prefixed
+    with "_php3_", 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'.
    
@@ -97,6 +80,7 @@ Naming Conventions
    between words.


+
 Syntax and indentation
 ----------------------

@@ -110,32 +94,25 @@ Syntax and indentation
    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 he or she is not used to, but,
+    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) {
+[3] Be generous with whitespace and braces.  Always prefer
+    if (foo) {
 		bar;
 	}
-
-	to:
-
+	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.

-[4] When indenting, use the tab character.  A tab is expected to represent
-    four spaces.  It is important to maintain consistency in indenture so
-    that definitions, comments, and control structures line up correctly.
-
 Documentation and Folding Hooks
 -------------------------------

@@ -146,8 +123,7 @@ function does.  It would look like this:

 /* {{{ proto int abs(int number)
   Return the absolute value of the number */
-PHP_FUNCTION(abs)
-{
+void php3_abs(INTERNAL_FUNCTION_PARAMETERS) {
   ...
 }
 /* }}} */
@@ -170,17 +146,4 @@ Optional arguments are written like this:

 And yes, please keep everything on a single line, even if that line is massive.

-Aliases & Legacy Documentation
-----------------------------------
-You may also have some deprecated aliases with close to duplicate
-names, for example, somedb_select_result and somedb_selectresult. For
-documentation puposes, these will only be documented by the most
-current name, with the aliases listed in the documentation for
-the parent function. For ease of reference, user-functions with
-completely different names, that alias to the same function (such as
-highlight_file and show_source), will be separately documented. The
-proto should still be included, describing which function is aliased.

-Backwards compatible functions and names should be maintained as long
-as the code can be reasonably be kept as part of the codebase. See
-/phpdoc/README for me information on documentation.
@@ -1,2 +1,3 @@
 For the list of people who've put work into PHP 4.0, please see
-http://www.php.net/credits.php
+http://www.php.net/version4/credits.php
+
@@ -1,363 +0,0 @@
-                     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@thieso.net>
-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@thieso.net>
-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:           openssl
-PRIMARY MAINTAINER:  Stig Venaas <venaas@php.net>
-MAINTENANCE:         Maintained
-STATUS:              Experimental
-------------------------------------------------------------------------------
-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:           satellite
-PRIMARY MAINTAINER:  David Eriksson <eriksson@php.net>
-MAINTENANCE:         Odd Fixes
-STATUS:              Experimental
-SINCE:               4.0.3
-------------------------------------------------------------------------------
-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@thieso.net>
-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?
@@ -1,82 +1,14 @@
 Installation Instructions for PHP 4.0
 -------------------------------------

+Note!  As of 4.0b3, PHP will require GNU make.
+
 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
+an Apache module for Apache 1.3.x with MySQL support.  A more verbose
+explanation follows.


-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)
+QUICK INSTALL

 $ gunzip -c apache_1.3.x.tar.gz | tar xf -
 $ cd apache_1.3.x
@@ -93,11 +25,10 @@ $ 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
+make
+ (you should now have an httpd binary which you can copy to your Apache bin dir)
+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
@@ -105,69 +36,25 @@ Edit your httpd.conf or srm.conf file and add:

 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
+   You will have downloaded a file named something like php4xn.tar.gz.
+   Unzip this file with a command like: gunzip php4xn.tar.gz

-   Next you have to untar it with: tar -xvf php-4.0.x.tar
+   Next you have to untar it with: tar -xvf php4xn.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
+2. Configure PHP.

   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
+   You can also use the supplied 'setup' script, which will ask you
+   a series of questions and automatically run the configure script
+   for you.

   The only options that you are likely to want to use are the ones in
   the last section entitled, "--enable and --with options recognized:"
@@ -194,16 +81,8 @@ Installing PHP can be done in four simple steps:
   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
@@ -261,49 +140,11 @@ Installing PHP can be done in four simple steps:
   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)
+4. Setting up the server.
   
   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
+   a backup of your previous one first.  Then edit your conf/srm.conf file
   and add the line:

      AddType application/x-httpd-php .php
@@ -317,71 +158,13 @@ Installing PHP can be done in four simple steps:
   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
+   When you are finished making changes to your srm.conf file, you can
   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
+USING PHP3 AND PHP4 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
+   scoping. This features make it possible to let PHP3 and PHP4 run as
   concurrent modules in one Apache server. 
   
   This feature is known to work on the following platforms:
@@ -389,9 +172,8 @@ USING PHP 3 AND PHP 4 AS CONCURRENT APACHE MODULES
   - Linux with recent binutils (binutils 2.9.1.0.25 tested)
   - Solaris 2.5 or better
   - FreeBSD (3.2, 4.0 tested)
-   - IRIX64 6.5
-
-   To enable it, configure PHP 3 and PHP 4 to use APXS (--with-apxs) and the
+   
+   To enable it, configure PHP3 and PHP4 to use APXS (--with-apxs) and the
   necessary link extensions (--enable-versioning). Otherwise, all standard
   installations instructions apply. For example:

@@ -1,6 +1,6 @@
 -------------------------------------------------------------------- 
-                  The PHP License, version 2.02
-Copyright (c) 1999, 2000 The PHP Group. All rights reserved.
+                  The PHP License, version 2.01
+Copyright (c) 1999 The PHP Group. All rights reserved.
 -------------------------------------------------------------------- 

 Redistribution and use in source and binary forms, with or without
@@ -37,17 +37,12 @@ are met:
     "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/. 
+  6. Permission to freely distribute and use Zend as an integrated
+     part of PHP is granted, under the conditions of version 0.91
+     of the Zend License.
+     The license is bundled with the Zend engine, and is available
+     at http://www.zend.com/license/0_91.txt, or by contacting
+     license@zend.com.



@@ -0,0 +1,97 @@
+                     List of PHP maintainers
+                     =======================
+
+Status 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.
+
+--------------------------------------------------------------------------------
+EXTENSION:           apache
+PRIMARY MAINTAINER:  Rasmus Lerdorf <rasmus@php.net>
+STATUS:              Maintained
+--------------------------------------------------------------------------------
+EXTENSION:           dba
+PRIMARY MAINTAINER:  Sascha Schumann <sascha@schumann.cx>
+STATUS:              Maintained
+--------------------------------------------------------------------------------
+EXTENSION:           fdf
+PRIMARY MAINTAINER:  Uwe Steinmann <steinm@php.net>
+STATUS:              Maintained
+--------------------------------------------------------------------------------
+EXTENSION:           gd
+PRIMARY MAINTAINER:  Rasmus Lerdorf <rasmus@php.net>
+STATUS:              Maintained
+--------------------------------------------------------------------------------
+EXTENSION:           hyperwave
+PRIMARY MAINTAINER:  Uwe Steinmann <steinm@php.net>
+STATUS:              Maintained
+--------------------------------------------------------------------------------
+EXTENSION:           informix
+PRIMARY MAINTAINER:  Danny Heijl <Danny.Heijl@cevi.be>
+STATUS:              Maintained
+--------------------------------------------------------------------------------
+EXTENSION:           java
+PRIMARY MAINTAINER:  Sam Ruby <rubys@us.ibm.com>
+STATUS:              Maintained
+--------------------------------------------------------------------------------
+EXTENSION:           ldap
+PRIMARY MAINTAINER:  Rasmus Lerdorf <rasmus@php.net>
+STATUS:              Odd Fixes
+--------------------------------------------------------------------------------
+EXTENSION:           mcrypt
+PRIMARY MAINTAINER:  Sascha Schumann <sascha@schumann.cx>
+STATUS:              Maintained
+--------------------------------------------------------------------------------
+EXTENSION:           mhash
+PRIMARY MAINTAINER:  Sascha Schumann <sascha@schumann.cx>
+STATUS:              Maintained
+--------------------------------------------------------------------------------
+EXTENSION:           mssql
+PRIMARY MAINTAINER:  Frank M. Kromann <fmk@swwwing.com>
+STATUS:              Maintained
+--------------------------------------------------------------------------------
+EXTENSION:           oci8
+PRIMARY MAINTAINER:  Thies C. Arntzen <thies@digicol.de>
+STATUS:              Maintained
+--------------------------------------------------------------------------------
+EXTENSION:           oracle
+PRIMARY MAINTAINER:  Thies C. Arntzen <thies@digicol.de>
+STATUS:              Maintained
+COMMENT:             Using the new OCI8 driver is encouraged where possible.
+--------------------------------------------------------------------------------
+EXTENSION:           pcre
+PRIMARY MAINTAINER:  Andrei Zmievski <andrei@ispi.net>
+STATUS:              Maintained
+--------------------------------------------------------------------------------
+EXTENSION:           pdf
+PRIMARY MAINTAINER:  Uwe Steinmann <steinm@php.net>
+STATUS:              Maintained
+--------------------------------------------------------------------------------
+EXTENSION:           session
+PRIMARY MAINTAINER:  Sascha Schumann <sascha@schumann.cx>
+STATUS:              Maintained
+--------------------------------------------------------------------------------
+EXTENSION:           snmp
+PRIMARY MAINTAINER:  Rasmus Lerdorf <rasmus@php.net>
+STATUS:              Odd Fixes
+--------------------------------------------------------------------------------
+EXTENSION:           wddx
+PRIMARY MAINTAINER:  Andrei Zmievski <andrei@ispi.net>
+STATUS:              Maintained
+--------------------------------------------------------------------------------
+EXTENSION:           xml
+PRIMARY MAINTAINER:  Thies C. Arntzen <thies@digicol.de>
+STATUS:              Maintained
+--------------------------------------------------------------------------------
+EXTENSION:           zlib
+PRIMARY MAINTAINER:  Stefan Roehrich <sr@linux.de>
+STATUS:              Maintained
+--------------------------------------------------------------------------------
@@ -0,0 +1,20 @@
+Module              Status
+------              ------
+MySQL               Working
+COM                 Working
+WDDX                Working
+PCRE                Working
+DBA                 Working
+mcrypt              Working
+mhash               Working
+dbase               Working
+aspell              Working
+imap                Working
+ldap                Working
+oci8                Working (but no blob-support yet)
+oracle              Working
+iptc                Working
+informix            Working
+zlib                Working
+sysvshm				Working
+odbc                Working (except for persistent connections)
@@ -0,0 +1,41 @@
+AUTOMAKE_OPTIONS = foreign
+
+ZEND_DIR = $(srcdir)/libzend
+SUBDIRS = libzend ext sapi $(TSRM_DIR) $(REGEX_DIR)
+
+BUILDLDFLAGS = $(EXTRA_LDFLAGS) $(LDFLAGS)
+
+phptemp_LTLIBRARIES = libphp4.la
+libphp4_la_SOURCES = \
+       main.c internal_functions.c snprintf.c php3_sprintf.c \
+       configuration-parser.y configuration-scanner.l request_info.c \
+       safe_mode.c fopen-wrappers.c php3_realpath.c alloca.c \
+       php_ini.c SAPI.c rfc1867.c dlist.c php_content_types.c strlcpy.c \
+	   strlcat.c mergesort.c
+
+libphp4_la_DEPENDENCIES = \
+		libzend/libzend.la \
+		sapi/$(PHP_SAPI)/libphpsapi_$(PHP_SAPI).la \
+		$(REGEX_LIB) \
+		$(EXT_LTLIBS) \
+		$(TSRM_LIB)
+
+libphp4_la_LIBADD = $(libphp4_la_DEPENDENCIES) $(EXTRA_LIBS)
+	
+libphp4_la_LDFLAGS = $(BUILDLDFLAGS) $(PHP_RPATHS)		
+	
+configuration-parser.h configuration-parser.c: configuration-parser.y
+	$(YACC) -p cfg -v -d $< -o configuration-parser.c
+
+configuration-scanner.c: configuration-scanner.l
+	$(LEX) -Pcfg -o$@ -i $<
+
+EXTRA_PROGRAMS = php
+
+noinst_PROGRAMS = $(PHP_PROGRAM)
+php_SOURCES = stub.c
+php_LDADD = libphp4.la
+php_LDFLAGS = -export-dynamic
+
+install-data-local:
+	$(INSTALL_IT)
@@ -1,56 +0,0 @@
-
-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:
@@ -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
@@ -1,6 +0,0 @@
-As of PHP 4.0.4, the BC math library routines are bundled in the
-standard PHP distribution.  There is no need to install any additional
-files.
-
-Thanks goes to Phil Nelson, for releasing the BC math library routines
-under the LGPL.
@@ -19,7 +19,7 @@ Having said that, here are the organizational rules:

   2. Discuss any significant changes on the list before committing. 

-   3. Look at EXTENSIONS file to see who is the primary maintainer of
+   3. Look at MAINTANERS 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
@@ -62,9 +62,7 @@ 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.
+lines, you have to put # or @ at the beginning of _every_ such line.

 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
@@ -1,185 +0,0 @@
-
-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 additional short description may be added after the parameters. 
-  If present it will be filled into the 'proto' header comments in the stubs
-  code and the <refpurpose> tag in the XML documentation.
-
-  An example:
-
-    my_function(int arg1, int arg2 [, int arg3 [, int arg4]]) this is my 1st
-
-  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");
-}
-/* }}} */
-
@@ -1,174 +0,0 @@
-$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
@@ -1,153 +0,0 @@
-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.)
-
-If you are using 3rd party tools and libraries which are installed
-in non-standard locations, you may need to set the environment
-variable LD_LIBRARY_PATH to point to the library's location, prior
-to running the Zeus Web Server. For example, if you have compiled
-external MySQL support, and mysql is installed in /usr/local/mysql,
-you should set LD_LIBRARY_PATH to '/usr/local/mysql/lib/mysql'
-and then 'export LD_LIBRARY_PATH'. For convenience, you should add
-this to the 'start-zeus' script provided.
-
-Yet another method of ensuring the linked libraries are found is to
-set the environment variable LD_RUN_PATH before compiling PHP. This
-works in a similar way to LD_LIBRARY_PATH, but at compile-time.
-Libraries produced with this envrionment variable set will have its
-value 'burned' into the resultant binary, specifying a runtime
-search pth to locate other required libraries such as MySQL.
-
-On Linux, you can also tell the dynamic linker where to find the
-libraries, by adding '/usr/local/mysql/lib/mysql' to the file 
-/etc/ld.so.conf - after editting this file, run 'ldconfig' as root,
-to use the changes.
-
-
-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:
-Some people may find they need to run ./configure with the
-'--enable-libgcc' compile option too.
-
-
-Performance issues
-==================
-
-To make PHP run fast under Zeus, check the following points:
-
-1) Run PHP as an ISAPI module, not a CGI - compile it with the --with-zeus=...
-   flag!
-
-2) Tune the ISAPI runner to your required workload. There are several
-   tuneables that can be given. These are set by adding the appropriate
-   lines to the $ZEUSHOME/web/global.cfg file. Changes to this file will only
-   be picked up after the web server is restarted (run stop-zeus ; start-zeus)
-
-   tuning!modules!isapi!external!maxthreads xxx
-
-   - Sets the maximum number of threads that the ISAPI runner will spawn. If
-     further PHP page requests arrive, they will be queued until a current
-     page is finished. For busy websites, we suggest increasing this value
-     (defaults to 16). Replace the 'xxx' in the above line with the required
-     number of threads. Note that the threads are equally shared between
-     ISAPI extensions and filters, so if you want to handle 100 concurrent
-     PHP page requests, set this tuneable to 200.
-
-   tuning!modules!isapi!external!minthreads xxx
-
-   - Sets the minimum number of threads. Idle threads will be kept in a pool,
-     which avoids costly thread creation/deletion.
-
-
-For more information and help with Zeus, please visit our website:
-http://support.zeus.com
@@ -1,110 +1,7 @@
 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.
-    * native large number support (probably with GNU GMP)
-    * Const'ify APIs. Right now, many functions leave parameters untouched,
-      but don't declare those as const. This makes interaction with other
-      interfaces difficult which pass const parameters to us. 
-
-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
-    * 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 (DONE?).
-    * 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/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
--------
-    * 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
 ------------
-    * array_mean()
-    * add a version number to data serialized via serialize().
-    * array_add(). (Andrei)
-    * possibly modify parsing of GPC data to automatically create arrays if
-      variable name is seen more than once.
-    * implement regex-cache for url-functions.
-    * 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()
-    * rewrite win32 SMTP code to be useable for *ix to, maybe as a (default)
-      module of its own (Hartmut)
-
-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
+	* strpad() (Andrei)
+    * advanced sort (Andrei)
@@ -0,0 +1,75 @@
+
+
+This is the ChangeLog from PHP3 as of Apr 12 1999. 
+
+Entries should be removed from this file, if you transfer changes
+over to PHP4.
+
+============================================================================
+
+?? 1999, Version 3.0.8
+- added Oracle-OCI8 persistent connections
+- fixed OCIDefineByName crash.
+- fixed some NULL-column related problems in OCI8-module.
+- Some Informix driver improvements.
+- PUT method support (mlemos@acm.org)
+- Fix parameter count problem in odbc_setoption()
+- Really fix implode() this time.  The fix in 3.0.7 was bogus
+- Make fgetss() slightly smarter
+- Add strip_tags() which uses the fgetss state-machine but acts on a string
+
+March 1 1999, Version 3.0.7
+- Added pdf_put_image and pdf_execute_image
+- Initial work on an ImageMagick module - doesn't do anything yet
+- Make configure script detect Netscape's LDAP SDK automagically
+- Fixed Oracle-OCI8 module for windows.
+- Add OCIRowCount function. (Number of affected rows for update-statements)
+- Add OCIDefineByName function.
+- Change the behaviour of open_basedir. It's now possible to supply more
+  than one directory. open_basedir paths from parent directories are now
+  automatically inherited.
+- fix rand() and mt_rand() to make the ranges work correctly
+- htmlspecialchars() and htmlentities() are now binary safe.
+- Add extract() function.
+- Oracle-OCI8 driver now supports BLOBS/CLOBS and IN/OUT binding of local php
+  variables.
+- Clean up apxs build
+- Add INSTALL.REDHAT file to walk RedHat users through the install
+- Add function_exists() function.
+- Add another version of WDDX module
+  (we need to pick a single implementation here)
+- Fixed includes for iODBC to support both the old and the new LGPL version
+- Fix implode() bug - When imploding an array that contained unset() elements
+  it wasn't correctly skipping past these
+- Add connection_status() function.  This returns the raw bitfield which
+  indicates whether the script terminated due to a user abort, a timeout
+  or normally.  Note that if ignore_user_abort is enabled, then both the
+  timeout state and the user abort state can be active
+- Add connection_timeout() function.  This one can be called in a shutdown
+  function to tell you if you got there because of a timeout
+- Add ignore_user_abort() function and .ini/.conf directive of same name
+- Fix connection abort detection code - It should now work reliably with
+  Apache.  Also added a user-level connection_aborted() function designed to
+  let people check whether the user aborted the connection in a user-level
+  shutdown function.
+- Add pfsockopen() function
+- Improvements in FreeType support: Macintosh fonts work, and non-antialiased
+  output is considerably cleaner  <mka@satama.com>
+- Fixed checkdate() function, range of valid years is now 0 to 32767
+- hw_insertdocument() returns object id now
+- Add pdf_open() warning in configure and documentation
+- Add diskfreespace() function
+- Added aspell support
+- Iptcparse would sometimes find a wrong tag.
+- Force var_dump() to output headers
+- Add optional 3th parameter to ora_fetchinto.
+- Serialize and var_dump no longer show array elements that
+  have been unset.
+- Add IptcEmbed() function (can replace an APP13-Marker in a JPEG file)
+- Add OCI8 module for Windows
+- Fix bug in pdf_close() function
+- Add WDDX support (see http://www.wddx.org for more info)
+- Add similar_text() function
+- Introduce simple regex compilation cache
+
+
@@ -1,26 +0,0 @@
-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.
@@ -1,6 +1,4 @@
 ## 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:
+libtsrm_la_SOURCES = TSRM.c
@@ -1,2 +0,0 @@
- Improve the lock in ts_resource_ex() in order to cover less code.
-  This can probably be done by more careful hash table access
@@ -2,18 +2,19 @@
   +----------------------------------------------------------------------+
   | 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                                |
+   | Copyright (c) 1998, 1999 Zeev Suraski                                |
   +----------------------------------------------------------------------+
-   | Authors:  Zeev Suraski <zeev@zend.com>                               |
+   | This source file is subject to the Zend license, that is bundled     |
+   | with this package in the file LICENSE.  If you did not receive a     |
+   | copy of the Zend license, please mail us at zend@zend.com so we can  |
+   | send you a copy immediately.                                         |
+   +----------------------------------------------------------------------+
+   | Author:  Zeev Suraski <zeev@zend.com>                                |
   +----------------------------------------------------------------------+
 */

+
 #include "TSRM.h"
-
-#ifdef ZTS
-
 #include <stdio.h>
 #include <stdlib.h>

@@ -33,21 +34,18 @@ struct _tsrm_tls_entry {

 typedef struct {
 	size_t size;
-	ts_allocate_ctor ctor;
-	ts_allocate_dtor dtor;
+	void (*ctor)(void *resource);
+	void (*dtor)(void *resource);
 } tsrm_resource_type;


-#define TSRM_SHUFFLE_RSRC_ID(rsrc_id)		((rsrc_id)+1)
-#define TSRM_UNSHUFFLE_RSRC_ID(rsrc_id)		((rsrc_id)-1)
-
 /* The memory manager table */
-static tsrm_tls_entry	**tsrm_tls_table=NULL;
+static 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=NULL;
+static tsrm_resource_type	*resource_types_table;
 static int					resource_types_table_size;


@@ -58,31 +56,16 @@ static void (*tsrm_new_thread_begin_handler)();
 static void (*tsrm_new_thread_end_handler)();

 /* Debug support */
-int tsrm_error(int level, const char *format, ...);
-static int tsrm_error_level;
-static FILE *tsrm_error_file;
-#if TSRM_DEBUG
-#define TSRM_ERROR tsrm_error
-#define TSRM_SAFE_ARRAY_OFFSET(array, offset, range)	(((offset)>=0 && (offset)<(range)) ? array[offset] : NULL)
-#else
-#define TSRM_ERROR
-#define TSRM_SAFE_ARRAY_OFFSET(array, offset, range)	array[offset]
-#endif
+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_level, char *debug_filename)
+TSRM_API int tsrm_startup(int expected_threads, int expected_resources, int debug_status)
 {
-#if defined(GNUPTH)
-	pth_init();
-#endif
-
-	tsrm_error_file = stderr;
-	tsrm_error_set(debug_level, debug_filename);
 	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) {
-		TSRM_ERROR(TSRM_ERROR_LEVEL_ERROR, "Unable to allocate TLS table");
 		return 0;
 	}
 	id_count=0;
@@ -90,9 +73,7 @@ TSRM_API int tsrm_startup(int expected_threads, int expected_resources, int debu
 	resource_types_table_size = expected_resources;
 	resource_types_table = (tsrm_resource_type *) calloc(resource_types_table_size, sizeof(tsrm_resource_type));
 	if (!resource_types_table) {
-		TSRM_ERROR(TSRM_ERROR_LEVEL_ERROR, "Unable to allocate resource types table");
 		free(tsrm_tls_table);
-		tsrm_tls_table = NULL;
 		return 0;
 	}

@@ -100,13 +81,15 @@ TSRM_API int tsrm_startup(int expected_threads, int expected_resources, int debu

 	tsrm_new_thread_begin_handler = tsrm_new_thread_end_handler = NULL;

-	TSRM_ERROR(TSRM_ERROR_LEVEL_CORE, "Started up TSRM, %d expected threads, %d expected resources", expected_threads, expected_resources);
+	tsrm_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)
+TSRM_API void tsrm_shutdown()
 {
 	int i;

@@ -127,45 +110,34 @@ TSRM_API void tsrm_shutdown(void)
 			}
 		}
 		free(tsrm_tls_table);
-		tsrm_tls_table = NULL;
 	}
 	if (resource_types_table) {
 		free(resource_types_table);
-		resource_types_table=NULL;
 	}
 	tsrm_mutex_free(tsmm_mutex);
-	tsmm_mutex = NULL;
-	TSRM_ERROR(TSRM_ERROR_LEVEL_CORE, "Shutdown TSRM");
-	if (tsrm_error_file!=stderr) {
-		fclose(tsrm_error_file);
-	}
-#if defined(GNUPTH)
-	pth_kill();
-#endif
+	tsrm_debug("Shutdown TSRM\n");
 }


 /* 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)
+TSRM_API ts_rsrc_id ts_allocate_id(size_t size, void (*ctor)(void *resource), void (*dtor)(void *resource))
 {
 	ts_rsrc_id new_id;
 	int i;

-	TSRM_ERROR(TSRM_ERROR_LEVEL_CORE, "Obtaining a new resource id, %d bytes", size);
+	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_ERROR(TSRM_ERROR_LEVEL_CORE, "Obtained resource id %d", TSRM_SHUFFLE_RSRC_ID(new_id));
+	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) {
-			tsrm_mutex_unlock(tsmm_mutex);
-			TSRM_ERROR(TSRM_ERROR_LEVEL_ERROR, "Unable to allocate storage for resource");
-			return 0;
+			return -1;
 		}
 		resource_types_table_size = id_count;
 	}
@@ -195,8 +167,8 @@ TSRM_API ts_rsrc_id ts_allocate_id(size_t size, ts_allocate_ctor ctor, ts_alloca
 	}
 	tsrm_mutex_unlock(tsmm_mutex);

-	TSRM_ERROR(TSRM_ERROR_LEVEL_CORE, "Successfully allocated new resource id %d", TSRM_SHUFFLE_RSRC_ID(new_id));
-	return TSRM_SHUFFLE_RSRC_ID(new_id);
+	tsrm_debug("Successfully allocated new resource id %d\n", new_id);
+	return new_id;
 }


@@ -204,7 +176,6 @@ static void allocate_new_resource(tsrm_tls_entry **thread_resources_ptr, THREAD_
 {
 	int i;

-	TSRM_ERROR(TSRM_ERROR_LEVEL_CORE, "Creating data structures for thread %x", thread_id);
 	(*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;
@@ -229,19 +200,14 @@ static void allocate_new_resource(tsrm_tls_entry **thread_resources_ptr, THREAD_


 /* fetches the requested resource for the current thread */
-TSRM_API void *ts_resource_ex(ts_rsrc_id id, THREAD_T *th_id)
+void *ts_resource(ts_rsrc_id id)
 {
-	THREAD_T thread_id;
+	THREAD_T thread_id = tsrm_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_ERROR(TSRM_ERROR_LEVEL_INFO, "Fetching resource id %d for thread %ld", id, (long) 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);
@@ -269,21 +235,17 @@ TSRM_API void *ts_resource_ex(ts_rsrc_id id, THREAD_T *th_id)
 		 } while (thread_resources);
 	}

-	resource = TSRM_SAFE_ARRAY_OFFSET(thread_resources->storage, TSRM_UNSHUFFLE_RSRC_ID(id), thread_resources->count);
+	resource = thread_resources->storage[id];

 	tsrm_mutex_unlock(tsmm_mutex);

-	if (resource) {
-		TSRM_ERROR(TSRM_ERROR_LEVEL_INFO, "Successfully fetched resource id %d for thread id %ld - %x", id, (long) thread_id, (long) resource);
-	} else {
-		TSRM_ERROR(TSRM_ERROR_LEVEL_ERROR, "Resource id %d is out of range (%d..%d)", id, TSRM_SHUFFLE_RSRC_ID(0), TSRM_SHUFFLE_RSRC_ID(thread_resources->count-1));
-	}
+	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)
+void ts_free_thread()
 {
 	THREAD_T thread_id = tsrm_thread_id();
 	int hash_value;
@@ -337,10 +299,8 @@ void ts_free_id(ts_rsrc_id id)
 /* Obtain the current thread id */
 TSRM_API THREAD_T tsrm_thread_id(void)
 {
-#ifdef TSRM_WIN32
+#ifdef WIN32
 	return GetCurrentThreadId();
-#elif defined(GNUPTH)
-	return pth_self();
 #elif defined(PTHREADS)
 	return pthread_self();
 #elif defined(NSAPI)
@@ -352,16 +312,12 @@ TSRM_API THREAD_T tsrm_thread_id(void)


 /* Allocate a mutex */
-TSRM_API MUTEX_T tsrm_mutex_alloc(void)
+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);
+#ifdef WIN32
+    mutexp = CreateMutex(NULL,FALSE,NULL);
 #elif defined(PTHREADS)
 	mutexp = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t));
 	pthread_mutex_init(mutexp,NULL);
@@ -378,15 +334,12 @@ TSRM_API MUTEX_T tsrm_mutex_alloc(void)


 /* Free a mutex */
-TSRM_API void tsrm_mutex_free(MUTEX_T mutexp)
+TSRM_API void tsrm_mutex_free( MUTEX_T mutexp )
 {
    if (mutexp) {
-#ifdef TSRM_WIN32
-		DeleteCriticalSection(mutexp);
-#elif defined(GNUPTH)
-		free(mutexp);
+#ifdef WIN32
+		CloseHandle(mutexp);
 #elif defined(PTHREADS)
-		pthread_mutex_destroy(mutexp);
 		free(mutexp);
 #elif defined(NSAPI)
 		crit_terminate(mutexp);
@@ -401,14 +354,13 @@ TSRM_API void tsrm_mutex_free(MUTEX_T mutexp)


 /* Lock a mutex */
-TSRM_API int tsrm_mutex_lock(MUTEX_T mutexp)
+TSRM_API int tsrm_mutex_lock( MUTEX_T mutexp )
 {
-	TSRM_ERROR(TSRM_ERROR_LEVEL_INFO, "Mutex locked thread: %ld", tsrm_thread_id());
-#ifdef TSRM_WIN32
-	EnterCriticalSection(mutexp);
-	return 1;
-#elif defined(GNUPTH)
-	return pth_mutex_acquire(mutexp, 0, NULL);
+#if 0
+	tsrm_debug("Mutex locked thread: %ld\n",tsrm_thread_id());
+#endif
+#ifdef WIN32
+    return WaitForSingleObject(mutexp,1000);
 #elif defined(PTHREADS)
 	return pthread_mutex_lock(mutexp);
 #elif defined(NSAPI)
@@ -420,14 +372,13 @@ TSRM_API int tsrm_mutex_lock(MUTEX_T mutexp)


 /* Unlock a mutex */
-TSRM_API int tsrm_mutex_unlock(MUTEX_T mutexp)
+TSRM_API int tsrm_mutex_unlock( MUTEX_T mutexp )
 {
-	TSRM_ERROR(TSRM_ERROR_LEVEL_INFO, "Mutex unlocked thread: %ld", tsrm_thread_id());
-#ifdef TSRM_WIN32
-	LeaveCriticalSection(mutexp);
-	return 1;
-#elif defined(GNUPTH)
-	return pth_mutex_release(mutexp);
+#if 0
+	tsrm_debug("Mutex unlocked thread: %ld\n",tsrm_thread_id());
+#endif
+#ifdef WIN32
+    return ReleaseMutex(mutexp);
 #elif defined(PTHREADS)
 	return pthread_mutex_unlock(mutexp);
 #elif defined(NSAPI)
@@ -461,45 +412,23 @@ TSRM_API void *tsrm_set_new_thread_end_handler(void (*new_thread_end_handler)(TH
 * Debug support
 */

-#if TSRM_DEBUG
-int tsrm_error(int level, const char *format, ...)
+static int tsrm_debug(const char *format, ...)
 {
-	if (level<=tsrm_error_level) {
+	if (tsrm_debug_status) {
 		va_list args;
 		int size;

-		fprintf(tsrm_error_file, "TSRM:  ");
 		va_start(args, format);
-		size = vfprintf(tsrm_error_file, format, args);
+		size = vprintf(format, args);
 		va_end(args);
-		fprintf(tsrm_error_file, "\n");
-		fflush(tsrm_error_file);
 		return size;
 	} else {
 		return 0;
 	}
 }
-#endif


-void tsrm_error_set(int level, char *debug_filename)
+void tsrm_debug_set(int status)
 {
-	tsrm_error_level = level;
-
-#if TSRM_DEBUG
-	if (tsrm_error_file!=stderr) { /* close files opened earlier */
-		fclose(tsrm_error_file);
-	}
-
-	if (debug_filename) {
-		tsrm_error_file = fopen(debug_filename, "w");
-		if (!tsrm_error_file) {
-			tsrm_error_file = stderr;
-		}
-	} else {
-		tsrm_error_file = stderr;
-	}
-#endif
+	tsrm_debug_status = status;
 }
-
-#endif /* ZTS */
@@ -19,7 +19,6 @@ CFG=TSRM - Win32 Debug_TS
 !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
@@ -42,7 +41,7 @@ RSC=rc.exe
 # 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" /D TSRM_DEBUG=1 /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "." /D "_DEBUG" /D "TSRM_EXPORTS" /D "WIN32" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
 # ADD BASE RSC /l 0x40d /d "_DEBUG"
 # ADD RSC /l 0x40d /d "_DEBUG"
 BSC32=bscmake.exe
@@ -65,30 +64,7 @@ LIB32=link.exe -lib
 # 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" /D TSRM_DEBUG=0 /YX /FD /c
-# ADD BASE RSC /l 0x40d /d "NDEBUG"
-# ADD RSC /l 0x40d /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo
-
-!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" /D TSRM_DEBUG=0 /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "." /D "NDEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D "TSRM_EXPORTS" /YX /FD /c
 # ADD BASE RSC /l 0x40d /d "NDEBUG"
 # ADD RSC /l 0x40d /d "NDEBUG"
 BSC32=bscmake.exe
@@ -104,7 +80,6 @@ LIB32=link.exe -lib

 # 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"
@@ -112,14 +87,6 @@ LIB32=link.exe -lib

 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"

@@ -128,22 +95,6 @@ SOURCE=.\tsrm_virtual_cwd.c

 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
@@ -2,39 +2,38 @@
   +----------------------------------------------------------------------+
   | 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                                |
+   | Copyright (c) 1998, 1999 Zeev Suraski                                |
   +----------------------------------------------------------------------+
-   | Authors:  Zeev Suraski <zeev@zend.com>                               |
+   | This source file is subject to the Zend license, that is bundled     |
+   | with this package in the file LICENSE.  If you did not receive a     |
+   | copy of the Zend license, please mail us at zend@zend.com so we can  |
+   | send you a copy immediately.                                         |
+   +----------------------------------------------------------------------+
+   | Author:  Zeev Suraski <zeev@zend.com>                                |
   +----------------------------------------------------------------------+
 */

-#ifndef TSRM_H
-#define TSRM_H
+
+#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
+#if WIN32||WINNT
 # include <windows.h>
-#elif defined(GNUPTH)
-# include <pth.h>
 #elif defined(PTHREADS)
 # include <pthread.h>
 #endif

 typedef int ts_rsrc_id;

-#ifdef TSRM_WIN32
+#if WIN32||WINNT
 #	ifdef TSRM_EXPORTS
 #	define TSRM_API __declspec(dllexport)
 #	else
@@ -46,12 +45,9 @@ typedef int ts_rsrc_id;


 /* Define THREAD_T and MUTEX_T */
-#ifdef TSRM_WIN32
+#if defined(WIN32)
 # define THREAD_T DWORD
-# define MUTEX_T CRITICAL_SECTION *
-#elif defined(GNUPTH)
-# define THREAD_T pth_t
-# define MUTEX_T pth_mutex_t *
+# define MUTEX_T void *
 #elif defined(PTHREADS)
 # define THREAD_T pthread_t
 # define MUTEX_T pthread_mutex_t *
@@ -64,7 +60,6 @@ typedef int ts_rsrc_id;
 #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

@@ -73,29 +68,24 @@ extern "C" {
 #endif

 /* startup/shutdown */
-TSRM_API int tsrm_startup(int expected_threads, int expected_resources, int debug_level, char *debug_filename);
-TSRM_API void tsrm_shutdown(void);
+TSRM_API int tsrm_startup(int expected_threads, int expected_resources, int debug_status);
+TSRM_API void tsrm_shutdown();

 /* 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);
+TSRM_API ts_rsrc_id ts_allocate_id(size_t size, ts_allocate_ctor ctor, void (*dtor)(void *resource));

 /* 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)
+TSRM_API void *ts_resource(ts_rsrc_id id);

 /* frees all resources allocated for the current thread */
-TSRM_API void ts_free_thread(void);
+TSRM_API void ts_free_thread();

 /* deallocates all occurrences of a given id */
 TSRM_API void ts_free_id(ts_rsrc_id id);


 /* Debug support */
-#define TSRM_ERROR_LEVEL_ERROR	1
-#define TSRM_ERROR_LEVEL_CORE	2
-#define TSRM_ERROR_LEVEL_INFO	3
-TSRM_API int tsrm_error(int level, const char *format, ...);
-TSRM_API void tsrm_error_set(int level, char *debug_filename);
+TSRM_API void tsrm_debug_set(int status);

 /* utility functions */
 TSRM_API THREAD_T tsrm_thread_id(void);
@@ -111,6 +101,4 @@ TSRM_API void *tsrm_set_new_thread_end_handler(void (*new_thread_end_handler)(TH
 }
 #endif

-#endif /* ZTS */
-
-#endif /* TSRM_H */
+#endif /* _TSRM_H */
@@ -4,30 +4,30 @@ dnl Minimalistic configure.in for TSRM.
 dnl

 AC_INIT(TSRM.c)
-AM_INIT_AUTOMAKE(TSRM, 1.0, nodefine)
+AM_INIT_AUTOMAKE(TSRM, 1.0)
 AM_CONFIG_HEADER(tsrm_config.h)

-sinclude(tsrm.m4)
-	
-TSRM_BASIC_CHECKS
-TSRM_THREADS_CHECKS
-	
+AC_PROG_CC
+AM_PROG_CC_STDC
+AC_PROG_CC_C_O
+AC_PROG_RANLIB
+
 AM_PROG_LIBTOOL
 if test "$enable_debug" != "yes"; then
  AM_SET_LIBTOOL_VARIABLE([--silent])
 fi

-dnl TSRM_PTHREAD
+AC_CHECK_LIB(c_r, pthread_kill)
+AC_CHECK_LIB(pthread, pthread_kill)

-AC_CHECK_HEADERS(
-utime.h \
-dirent.h \
-stdarg.h \
-alloca.h \
-unistd.h \
-limits.h
-)
+AC_CHECK_FUNCS(pthread_kill)

-AC_DEFINE(ZTS,1,[ ])
+if test "$ac_cv_func_pthread_kill" != "yes"; then
+  AC_MSG_ERROR(You need pthreads to build TSRM.)
+fi
+
+AC_DEFINE(PTHREADS)
+
+AC_CHECK_HEADERS(stdarg.h)

 AC_OUTPUT(Makefile)
@@ -1,44 +0,0 @@
-#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 */
@@ -1,157 +0,0 @@
-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
@@ -1,98 +0,0 @@
-
-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
-
-])
@@ -1,15 +0,0 @@
-#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
@@ -1,47 +0,0 @@
-#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 */
@@ -1,63 +0,0 @@
-#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
@@ -1,6 +0,0 @@
-#ifndef TSRM_STRTOK_R
-#define TSRM_STRTOK_R
-
-char *tsrm_strtok_r(char *s, const char *delim, char **last);
-
-#endif
@@ -1,787 +0,0 @@
-/*
-   +----------------------------------------------------------------------+
-   | PHP version 4.0                                                      |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 1997, 1998, 1999, 2000 The PHP Group                   |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 2.02 of the PHP license,      |
-   | that is bundled with this package in the file LICENSE, and is        |
-   | available at through the world-wide-web at                           |
-   | http://www.php.net/license/2_02.txt.                                 |
-   | If you did not receive a copy of the PHP license and are unable to   |
-   | obtain it through the world-wide-web, please send a note to          |
-   | license@php.net so we can mail you a copy immediately.               |
-   +----------------------------------------------------------------------+
-   | Authors: 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(size_t *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_ex(const char *path, char **filepath, verify_path_func verify_path)
-{
-	cwd_state new_state;
-	int retval;
-	CWDLS_FETCH();
-
-	CWD_STATE_COPY(&new_state, &CWDG(cwd));
-	retval = virtual_file_ex(&new_state, path, verify_path);
-
-	*filepath = new_state.cwd;
-
-	return retval;
-
-}
-
-CWD_API int virtual_filepath(const char *path, char **filepath)
-{
-	return virtual_filepath_ex(path, filepath, php_is_file_ok);
-}
-
-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_rename(char *oldname, char *newname)
-{
-	cwd_state old_state;
-	cwd_state new_state;
-	int retval;
-	CWDLS_FETCH();
-
-	CWD_STATE_COPY(&old_state, &CWDG(cwd));
-	virtual_file_ex(&old_state, oldname, NULL);
-	oldname = old_state.cwd;
-
-	CWD_STATE_COPY(&new_state, &CWDG(cwd));
-	virtual_file_ex(&new_state, newname, NULL);
-	newname = new_state.cwd;
- 
-	retval = rename(oldname, newname);
-
-	CWD_STATE_FREE(&old_state);
-	CWD_STATE_FREE(&new_state);
-
-	return retval;
-}
-
-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:
- */
@@ -1,212 +0,0 @@
-/*
-   +----------------------------------------------------------------------+
-   | PHP version 4.0                                                      |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 1997, 1998, 1999, 2000 The PHP Group                   |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 2.02 of the PHP license,      |
-   | that is bundled with this package in the file LICENSE, and is        |
-   | available at through the world-wide-web at                           |
-   | http://www.php.net/license/2_02.txt.                                 |
-   | If you did not receive a copy of the PHP license and are unable to   |
-   | obtain it through the world-wide-web, please send a note to          |
-   | license@php.net so we can mail you a copy immediately.               |
-   +----------------------------------------------------------------------+
-   | Authors: 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 unsigned short 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(size_t *length);
-CWD_API char *virtual_getcwd(char *buf, size_t size);
-CWD_API int virtual_chdir(const char *path);
-CWD_API int virtual_chdir_file(const char *path, int (*p_chdir)(const char *path));
-CWD_API int virtual_filepath(const char *path, char **filepath);
-CWD_API int virtual_filepath_ex(const char *path, char **filepath, verify_path_func verify_path);
-CWD_API char *virtual_realpath(const char *path, char *real_path);
-CWD_API FILE *virtual_fopen(const char *path, const char *mode);
-CWD_API int virtual_open(const char *path, int flags, ...);
-CWD_API int virtual_creat(const char *path, mode_t mode);
-CWD_API int virtual_rename(char *oldname, char *newname);
-CWD_API int virtual_stat(const char *path, struct stat *buf);
-#ifndef TSRM_WIN32
-CWD_API int virtual_lstat(const char *path, struct stat *buf);
-#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_RENAME(oldname,newname) virtual_rename(oldname,newname)
-#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_RENAME(oldname,newname) rename(oldname,newname)
-#define V_CHDIR(path) chdir(path)
-#define V_CHDIR_FILE(path) virtual_chdir_file(path, chdir)
-#define V_GETWD(buf) getwd(buf)
-#define V_STAT(path, buff) stat(path, buff)
-#define V_LSTAT(path, buff) lstat(path, buff)
-#define V_UNLINK(path) unlink(path)
-#define V_MKDIR(pathname, mode) mkdir(pathname, mode)
-#define V_RMDIR(pathname) rmdir(pathname)
-#define V_OPENDIR(pathname) opendir(pathname)
-#define V_POPEN(command, type) popen(command, type)
-#define V_REALPATH(path,real_path) realpath(path,real_path)
-#if HAVE_UTIME
-#define 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 */
@@ -41,9 +41,9 @@
 //	#include <FlexLexer.h>
 //	...

-#ifndef FLEXLEXER_H
+#ifndef __FLEX_LEXER_H
 // Never included before - need to define base class.
-#define FLEXLEXER_H
+#define __FLEX_LEXER_H
 #include <iostream.h>

 extern "C++" {
@@ -1,11 +1,11 @@
 ---------------------------------------------------------------------------
-                    The Zend License, version 0.92
-           Copyright (C) 1999-2000    Zend Technologies Ltd.
+                    The Zend License, version 0.91
+           Copyright (C) 1999    Andi Gutmans & Zeev Suraski
 ---------------------------------------------------------------------------

-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.
+The Zend scripting engine library is a product of Andi Gutmans and
+Zeev Suraski.  It may be used and/or distributed under the terms of the
+Q Public License (QPL) version 1.0, enclosed below.

 For more information about Zend please visit http://www.zend.com/
 For license related questions please mail license@zend.com
@@ -113,4 +113,4 @@ OF ANY KIND, INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS
 FOR A PARTICULAR PURPOSE.


-===========================================================================
+===========================================================================
@@ -1,60 +1,38 @@
 ## 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 
+
+ZEND_SCANNER = @ZEND_SCANNER@

 AUTOMAKE_OPTIONS=foreign
-EXTRA_LTLIBRARIES=libZend_cc.la libZend_c.la
-noinst_LTLIBRARIES=$(ZEND_SCANNER) libZend.la
+EXTRA_LTLIBRARIES=libzend_cc.la libzend_c.la
+noinst_LTLIBRARIES=$(ZEND_SCANNER) libzend.la

-libZend_cc_la_SOURCES=zend_language_scanner_cc.cc zend_ini_scanner_cc.cc
-libZend_c_la_SOURCES=zend_language_scanner.c zend_ini_scanner.c
+libzend_cc_la_SOURCES=zend-scanner-cc.cc
+libzend_c_la_SOURCES=zend-scanner.c

-libZend_la_SOURCES=\
-	zend_language_parser.y \
-	zend_ini_parser.y \
-	zend_alloc.c zend_compile.c zend_constants.c zend_dynamic_array.c \
+libzend_la_SOURCES=\
+	zend-parser.y \
+	zend_alloc.c zend_compile.c zend_constants.c \
 	zend_execute.c zend_execute_API.c zend_highlight.c zend_llist.c \
 	zend_opcode.c zend_operators.c zend_ptr_stack.c zend_stack.c \
 	zend_variables.c zend.c zend_API.c zend_extensions.c zend_hash.c \
-	zend_list.c zend_indent.c zend_builtin_functions.c zend_sprintf.c \
-	zend_ini.c
-
-libZend_la_LIBADD = $(ZEND_SCANNER)
-libZend_la_LDFLAGS = @EXTRA_LIBS@
-libZend_la_DEPENDENCIES = $(ZEND_SCANNER)
+	zend_list.c zend_indent.c zend_builtin_functions.c

+libzend_la_LIBADD = $(ZEND_SCANNER)
+libzend_la_LDFLAGS = @EXTRA_LIBS@
+	
 # automake isn't too clever about "non-standard" use of lex and yacc

-$(libZend_la_OBJECTS) zend_language_scanner.lo zend_language_scanner_cc.lo: zend_language_parser.h
+zend-scanner.l: zend-parser.h

-zend_ini_scanner.lo zend_ini_scanner_cc.lo: zend_ini_parser.h
+zend-scanner.c: zend-scanner.l
+	$(LEX) -Pzend -o$@ -i $(srcdir)/zend-scanner.l

-# Language parser/scanner rules
+zend-scanner-cc.cc: 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 -o$@ -i $(srcdir)/zend_language_scanner.l
-
-zend_language_scanner_cc.cc: $(srcdir)/zend_language_scanner.l
-	$(LEX) -+ -B -i -S$(srcdir)/flex.skl -Pzend -o$@ $(srcdir)/zend_language_scanner.l
-
-zend_language_parser.h: zend_language_parser.c
-zend_language_parser.c: $(srcdir)/zend_language_parser.y
-	$(YACC) -p zend -v -d $(srcdir)/zend_language_parser.y -o zend_language_parser.c
-
-# INI parser/scanner rules
-
-zend_ini_parser.c: $(srcdir)/zend_ini_parser.y
-	$(YACC) -p ini_ -v -d $(srcdir)/zend_ini_parser.y -o zend_ini_parser.c
-
-zend_ini_scanner.c: $(srcdir)/zend_ini_scanner.l
-	$(LEX) -Pini_ -o$@ -i $(srcdir)/zend_ini_scanner.l
-
-zend_ini_scanner_cc.cc: $(srcdir)/zend_ini_scanner.l
-	$(LEX) -+ -B -i -S$(srcdir)/flex.skl -Pini_ -o$@ $(srcdir)/zend_ini_scanner.l
-zend_ini_parser.h: zend_ini_parser.c
-
-depend:
-
-zend_execute.lo: $(srcdir)/zend_execute.c
-	$(LIBTOOL) --mode=compile $(CC) $(DEFS) $(INCLUDES) $(CPPFLAGS) $(INLINE_CFLAGS) -c $(srcdir)/zend_execute.c
+zend-parser.h: zend-parser.c
+zend-parser.c: zend-parser.y
+	$(YACC) -p zend -v -d $(srcdir)/zend-parser.y -o zend-parser.c

@@ -84,7 +84,7 @@ shamelessly lying about it.  Here's why:

 * static variable initializers only accept scalar values
  (in PHP 3.0 they accepted any valid expression).  The impact
-  should be somewhere in between void and non existent, since
+  should be somewhere in between void and non existant, since
  initializing a static variable with anything but a simple
  static value makes no sense at all.

@@ -109,4 +109,3 @@ shamelessly lying about it.  Here's why:
  This incompatability is due to the full variable reference
  within quoted strings feature added in Zend.
  
-
@@ -1,498 +0,0 @@
-# Microsoft Developer Studio Project File - Name="Zend" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Static Library" 0x0104
-
-CFG=Zend - Win32 Release_inline
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE 
-!MESSAGE NMAKE /f "Zend.mak".
-!MESSAGE 
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE 
-!MESSAGE NMAKE /f "Zend.mak" CFG="Zend - Win32 Release_inline"
-!MESSAGE 
-!MESSAGE Possible choices for configuration are:
-!MESSAGE 
-!MESSAGE "Zend - Win32 Release" (based on "Win32 (x86) Static Library")
-!MESSAGE "Zend - Win32 Debug" (based on "Win32 (x86) Static Library")
-!MESSAGE "Zend - Win32 Release_inline" (based on "Win32 (x86) Static Library")
-!MESSAGE 
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-RSC=rc.exe
-
-!IF  "$(CFG)" == "Zend - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Output_Dir "Release"
-# PROP BASE Intermediate_Dir "Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Output_Dir "Release"
-# PROP Intermediate_Dir "Release"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDebug" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /I "." /D "NDebug" /D "_LIB" /D "Zend_EXPORTS" /D ZEND_DEBUG=0 /D "LIBZEND_EXPORTS" /D "TSRM_EXPORTS" /D "WIN32" /D "_MBCS" /D "ZEND_WIN32" /FR /FD /c
-# SUBTRACT CPP /YX
-# ADD BASE RSC /l 0x40d /d "NDebug"
-# ADD RSC /l 0x40d /d "NDebug"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo
-
-!ELSEIF  "$(CFG)" == "Zend - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Output_Dir "Debug"
-# PROP BASE Intermediate_Dir "Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Output_Dir "Debug"
-# PROP Intermediate_Dir "Debug"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_Debug" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
-# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "." /D "_Debug" /D "_LIB" /D "LIBZEND_EXPORTS" /D "TSRM_EXPORTS" /D ZEND_DEBUG=1 /D "ZEND_WIN32" /D "WIN32" /D "_MBCS" /FR /YX /FD /GZ /c
-# ADD BASE RSC /l 0x40d /d "_Debug"
-# ADD RSC /l 0x40d /d "_Debug"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo
-
-!ELSEIF  "$(CFG)" == "Zend - Win32 Release_inline"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Output_Dir "Zend___Win32_Release_inline"
-# PROP BASE Intermediate_Dir "Zend___Win32_Release_inline"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Output_Dir "Release_inline"
-# PROP Intermediate_Dir "Release_inline"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /MD /W3 /GX /O2 /I "." /D "NDebug" /D "_LIB" /D "Zend_EXPORTS" /D ZEND_DEBUG=0 /D "LIBZEND_EXPORTS" /D "TSRM_EXPORTS" /D "WIN32" /D "_MBCS" /FR /FD /c
-# SUBTRACT BASE CPP /YX
-# ADD CPP /nologo /MD /W3 /GX /O2 /I "." /D "NDebug" /D "_LIB" /D "Zend_EXPORTS" /D "LIBZEND_EXPORTS" /D "TSRM_EXPORTS" /D ZEND_DEBUG=0 /D "ZEND_WIN32_FORCE_INLINE" /D "WIN32" /D "_MBCS" /D "ZEND_WIN32" /FR /FD /c
-# SUBTRACT CPP /YX
-# ADD BASE RSC /l 0x40d /d "NDebug"
-# ADD RSC /l 0x40d /d "NDebug"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo
-
-!ENDIF 
-
-# Begin Target
-
-# Name "Zend - Win32 Release"
-# Name "Zend - Win32 Debug"
-# Name "Zend - Win32 Release_inline"
-# Begin Group "Source Files"
-
-# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
-# Begin Source File
-
-SOURCE=.\zend.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_alloc.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_API.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_builtin_functions.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_compile.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_constants.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_execute.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_execute_API.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_extensions.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_hash.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_highlight.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_indent.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_ini.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_ini_parser.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_ini_scanner.c
-# End Source File
-# Begin Source File
-
-SOURCE=".\zend_language_parser.c"
-# End Source File
-# Begin Source File
-
-SOURCE=".\zend_language_scanner.c"
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_list.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_llist.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_opcode.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_operators.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_ptr_stack.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_sprintf.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_stack.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_variables.c
-# End Source File
-# End Group
-# Begin Group "Header Files"
-
-# PROP Default_Filter "h;hpp;hxx;hm;inl"
-# Begin Source File
-
-SOURCE=.\FlexLexer.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\modules.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_alloc.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_API.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_builtin_functions.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_compile.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_config.w32.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_constants.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_errors.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_execute.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_extensions.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_fast_cache.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_globals.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_hash.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_highlight.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_indent.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_ini.h
-# End Source File
-# Begin Source File
-
-SOURCE=".\zend_language_parser.h"
-# End Source File
-# Begin Source File
-
-SOURCE=".\zend_language_scanner.h"
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_list.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_llist.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_operators.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_ptr_stack.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_stack.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_variables.h
-# End Source File
-# End Group
-# Begin Group "Parsers"
-
-# PROP Default_Filter "y"
-# Begin Source File
-
-SOURCE=.\zend_ini_parser.y
-
-!IF  "$(CFG)" == "Zend - Win32 Release"
-
-!ELSEIF  "$(CFG)" == "Zend - Win32 Debug"
-
-# Begin Custom Build
-InputDir=.
-InputPath=.\zend_ini_parser.y
-
-BuildCmds= \
-	if not "X%CYGWIN%"=="X" bison --output=zend_ini_parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p ini_ zend_ini_parser.y \
-	if "X%CYGWIN%"=="X" bison --output=zend_ini_parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p ini_ zend_ini_parser.y \
-	
-
-"$(InputDir)\zend_ini_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-   $(BuildCmds)
-
-"$(InputDir)\zend_ini_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-   $(BuildCmds)
-# End Custom Build
-
-!ELSEIF  "$(CFG)" == "Zend - Win32 Release_inline"
-
-!ENDIF 
-
-# End Source File
-# Begin Source File
-
-SOURCE=".\zend_language_parser.y"
-
-!IF  "$(CFG)" == "Zend - Win32 Release"
-
-# Begin Custom Build
-InputDir=.
-InputPath=".\zend_language_parser.y"
-
-BuildCmds= \
-	if not "X%CYGWIN%"=="X" bison --output=zend_language_parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p zend zend_language_parser.y \
-	if "X%CYGWIN%"=="X" bison --output=zend_language_parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p zend zend_language_parser.y \
-	
-
-"$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-   $(BuildCmds)
-
-"$(InputDir)\zend_language_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-   $(BuildCmds)
-# End Custom Build
-
-!ELSEIF  "$(CFG)" == "Zend - Win32 Debug"
-
-# Begin Custom Build
-InputDir=.
-InputPath=".\zend_language_parser.y"
-
-BuildCmds= \
-	if not "X%CYGWIN%"=="X" bison --output=zend_language_parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p zend zend_language_parser.y \
-	if "X%CYGWIN%"=="X" bison --output=zend_language_parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p zend zend_language_parser.y \
-	
-
-"$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-   $(BuildCmds)
-
-"$(InputDir)\zend_language_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-   $(BuildCmds)
-# End Custom Build
-
-!ELSEIF  "$(CFG)" == "Zend - Win32 Release_inline"
-
-# Begin Custom Build
-InputDir=.
-InputPath=".\zend_language_parser.y"
-
-BuildCmds= \
-	if not "X%CYGWIN%"=="X" bison --output=zend_language_parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p zend zend_language_parser.y \
-	if "X%CYGWIN%"=="X" bison --output=zend_language_parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p zend zend_language_parser.y \
-	
-
-"$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-   $(BuildCmds)
-
-"$(InputDir)\zend_language_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-   $(BuildCmds)
-# End Custom Build
-
-!ENDIF 
-
-# End Source File
-# End Group
-# Begin Group "Scanners"
-
-# PROP Default_Filter "l"
-# Begin Source File
-
-SOURCE=.\zend_ini_scanner.l
-
-!IF  "$(CFG)" == "Zend - Win32 Release"
-
-!ELSEIF  "$(CFG)" == "Zend - Win32 Debug"
-
-# Begin Custom Build
-InputPath=.\zend_ini_scanner.l
-
-"zend_ini_scanner.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-	flex -B -i -Sflex.skl -Pini_ -ozend_ini_scanner.c zend_ini_scanner.l
-
-# End Custom Build
-
-!ELSEIF  "$(CFG)" == "Zend - Win32 Release_inline"
-
-!ENDIF 
-
-# End Source File
-# Begin Source File
-
-SOURCE=".\zend_language_scanner.l"
-
-!IF  "$(CFG)" == "Zend - Win32 Release"
-
-# Begin Custom Build
-InputPath=".\zend_language_scanner.l"
-
-"zend_language_scanner.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-	flex -i -Pzend -ozend_language_scanner.c zend_language_scanner.l
-
-# End Custom Build
-
-!ELSEIF  "$(CFG)" == "Zend - Win32 Debug"
-
-# Begin Custom Build
-InputPath=".\zend_language_scanner.l"
-
-"zend_language_scanner.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-	flex -i -Pzend -ozend_language_scanner.c zend_language_scanner.l
-
-# End Custom Build
-
-!ELSEIF  "$(CFG)" == "Zend - Win32 Release_inline"
-
-# Begin Custom Build
-InputPath=".\zend_language_scanner.l"
-
-"zend_language_scanner.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-	flex -i -Pzend -ozend_language_scanner.c zend_language_scanner.l
-
-# End Custom Build
-
-!ENDIF 
-
-# End Source File
-# End Group
-# Begin Group "Text Files"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=.\ZEND_BUGS
-# End Source File
-# Begin Source File
-
-SOURCE=.\ZEND_CHANGES
-# End Source File
-# Begin Source File
-
-SOURCE=.\ZEND_TODO
-# End Source File
-# End Group
-# Begin Group "Resources"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=.\zend.ico
-# End Source File
-# End Group
-# End Target
-# End Project
@@ -1,222 +0,0 @@
-
-AC_DEFUN(LIBZEND_BISON_CHECK,[
-
-if test "$YACC" != "bison -y"; then
-    AC_MSG_WARN(You will need bison if you want to regenerate the Zend parser.)
-else
-    AC_MSG_CHECKING(bison version)
-    set `bison --version| sed -e 's/^GNU Bison version //' -e 's/\./ /'`
-    if test "${1}" = "1" -a "${2}" -lt "28"; then
-        AC_MSG_WARN(You will need bison 1.28 if you want to regenerate the Zend parser (found ${1}.${2}).)
-    fi
-    AC_MSG_RESULT(${1}.${2} (ok))
-fi
-
-])
-
-AC_DEFUN(LIBZEND_BASIC_CHECKS,[
-
-AC_REQUIRE([AC_PROG_YACC])
-AC_REQUIRE([AC_PROG_CC])
-AC_REQUIRE([AC_PROG_CC_C_O])
-AC_REQUIRE([AM_PROG_LEX])
-AC_REQUIRE([AC_HEADER_STDC])
-
-LIBZEND_BISON_CHECK
-
-dnl Ugly hack to get around a problem with gcc on AIX.
-if test "$CC" = "gcc" -a "$ac_cv_prog_cc_g" = "yes" -a \
-   "`uname -sv`" = "AIX 4"; then
-	CFLAGS=`echo $CFLAGS | sed -e 's/-g//'`
-fi
-
-dnl Hack to work around a Mac OS X cpp problem
-dnl Known versions needing this workaround are 5.3 and 5.4
-if test "$ac_cv_prog_gcc" = "yes" -a "`uname -s`" = "Rhapsody"; then
-        CPPFLAGS="$CPPFLAGS -traditional-cpp"
-fi
-
-AC_CHECK_HEADERS(
-limits.h \
-malloc.h \
-string.h \
-unistd.h \
-stdarg.h \
-sys/types.h \
-signal.h \
-unix.h \
-dlfcn.h)
-
-AC_TYPE_SIZE_T
-AC_TYPE_SIGNAL
-
-AC_CHECK_LIB(dl, dlopen, [LIBS="-ldl $LIBS"])
-AC_CHECK_FUNC(dlopen,[AC_DEFINE(HAVE_LIBDL, 1,[ ])])
-
-dnl This is required for QNX and may be some BSD derived systems
-AC_CHECK_TYPE( uint, unsigned int )
-AC_CHECK_TYPE( ulong, unsigned long )
-
-
-dnl Checks for library functions.
-AC_FUNC_VPRINTF
-AC_FUNC_MEMCMP
-AC_FUNC_ALLOCA
-AC_CHECK_FUNCS(memcpy strdup getpid kill strtod strtol finite)
-AC_ZEND_BROKEN_SPRINTF
-
-AC_CHECK_FUNCS(finite isfinite isinf isnan)
-
-ZEND_FP_EXCEPT
-	
-AC_SUBST(ZEND_SCANNER)
-
-])
-
-
-
-
-
-AC_DEFUN(LIBZEND_ENABLE_DEBUG,[
-
-AC_ARG_ENABLE(debug,
-[  --enable-debug         Compile with debugging symbols],[
-  ZEND_DEBUG=$enableval
-],[
-  ZEND_DEBUG=no
-])  
-
-])
-
-
-
-
-
-
-
-
-
-
-
-
-AC_DEFUN(LIBZEND_OTHER_CHECKS,[
-
-AC_ARG_ENABLE(experimental-zts,
-[  --enable-experimental-zts   This will most likely break your build],[
-  ZEND_EXPERIMENTAL_ZTS=$enableval
-],[
-  ZEND_EXPERIMENTAL_ZTS=no
-])  
-
-AC_ARG_ENABLE(inline-optimization,
-[  --enable-inline-optimization   If you have much memory and are using
-                                 gcc, you might try this.],[
-  ZEND_INLINE_OPTIMIZATION=$enableval
-],[
-  ZEND_INLINE_OPTIMIZATION=no
-])
-
-AC_ARG_ENABLE(memory-limit,
-[  --enable-memory-limit   Compile with memory limit support. ], [
-  ZEND_MEMORY_LIMIT=$enableval
-],[
-  ZEND_MEMORY_LIMIT=no
-])
-
-AC_MSG_CHECKING(whether to enable experimental ZTS)
-AC_MSG_RESULT($ZEND_EXPERIMENTAL_ZTS)
-
-AC_MSG_CHECKING(whether to enable inline optimization for GCC)
-AC_MSG_RESULT($ZEND_INLINE_OPTIMIZATION)
-
-AC_MSG_CHECKING(whether to enable a memory limit)
-AC_MSG_RESULT($ZEND_MEMORY_LIMIT)
-
-AC_MSG_CHECKING(whether to enable Zend debugging)
-AC_MSG_RESULT($ZEND_DEBUG)
-	
-if test "$ZEND_DEBUG" = "yes"; then
-  AC_DEFINE(ZEND_DEBUG,1,[ ])
-  echo " $CFLAGS" | grep ' -g' >/dev/null || DEBUG_CFLAGS="-g"
-  if test "$CFLAGS" = "-g -O2"; then
-  	CFLAGS=-g
-  fi
-  test -n "$GCC" && DEBUG_CFLAGS="$DEBUG_CFLAGS -Wall"
-  test -n "$GCC" && test "$USE_MAINTAINER_MODE" = "yes" && \
-    DEBUG_CFLAGS="$DEBUG_CFLAGS -Wmissing-prototypes -Wstrict-prototypes -Wmissing-declarations"
-else
-  AC_DEFINE(ZEND_DEBUG,0,[ ])
-fi
-
-test -n "$DEBUG_CFLAGS" && CFLAGS="$CFLAGS $DEBUG_CFLAGS"
-
-if test "$ZEND_EXPERIMENTAL_ZTS" = "yes"; then
-  AC_DEFINE(ZTS,1,[ ])
-  ZEND_SCANNER_TYPE=cc
-  CPPFLAGS="$CPPFLAGS -I../TSRM"
-  LIBZEND_CPLUSPLUS_CHECKS
-else
-  ZEND_SCANNER_TYPE=c
-fi  
-
-ZEND_SCANNER="libZend_${ZEND_SCANNER_TYPE}.la"
-
-if test "$ZEND_MEMORY_LIMIT" = "yes"; then
-  AC_DEFINE(MEMORY_LIMIT, 1, [Memory limit])
-else
-  AC_DEFINE(MEMORY_LIMIT, 0, [Memory limit])
-fi
-
-changequote({,})
-if test -n "$GCC" && test "$ZEND_INLINE_OPTIMIZATION" != "yes"; then
-  INLINE_CFLAGS=`echo $ac_n "$CFLAGS $ac_c" | sed s/-O[0-9]*//`
-else
-  INLINE_CFLAGS="$CFLAGS"
-fi
-changequote([,])
-
-AC_C_INLINE
-
-AC_SUBST(INLINE_CFLAGS)
-
-])
-
-
-AC_DEFUN(LIBZEND_CPLUSPLUS_CHECKS,[
-
-dnl extra check to avoid C++ preprocessor testing if in non-ZTS mode
-		
-if test "$ZEND_EXPERIMENTAL_ZTS" = "yes"; then
-AC_PROG_CXX		
-AC_PROG_CXXCPP
-AC_LANG_CPLUSPLUS
-AC_CHECK_HEADER(stdiostream.h, [ AC_DEFINE(HAVE_STDIOSTREAM_H, [], Whether you have stdiostream.h) ])
-
-AC_CHECK_LIB(C, cin)
-AC_CHECK_LIB(g++, cin)
-AC_CHECK_LIB(stdc++, cin)
-dnl Digital Unix 4.0
-AC_CHECK_LIB(cxx, cin)
-AC_CHECK_LIB(cxxstd, __array_delete)
-
-AC_CACHE_CHECK(for class istdiostream,ac_cv_class_istdiostream,[
-AC_TRY_COMPILE([
-#include <sys/types.h>
-#include <unistd.h>
-#include <fstream.h>
-#include <stdiostream.h>
-],[
-istdiostream *foo = new istdiostream((FILE *) 0);
-],[
-  ac_cv_class_istdiostream=yes
-],[
-  ac_cv_class_istdiostream=no
-])
-])
-  if test "$ac_cv_class_istdiostream" = "yes"; then
-    AC_DEFINE(HAVE_CLASS_ISTDIOSTREAM, 1, [Whether you have class istdiostream])
-  fi
-AC_LANG_C
-fi
-])
-
@@ -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"\
@@ -1,570 +0,0 @@
-# Microsoft Developer Studio Project File - Name="ZendTS" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Static Library" 0x0104
-
-CFG=ZendTS - Win32 Release_TS_inline
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE 
-!MESSAGE NMAKE /f "ZendTS.mak".
-!MESSAGE 
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE 
-!MESSAGE NMAKE /f "ZendTS.mak" CFG="ZendTS - Win32 Release_TS_inline"
-!MESSAGE 
-!MESSAGE Possible choices for configuration are:
-!MESSAGE 
-!MESSAGE "ZendTS - Win32 Release_TS" (based on "Win32 (x86) Static Library")
-!MESSAGE "ZendTS - Win32 Debug_TS" (based on "Win32 (x86) Static Library")
-!MESSAGE "ZendTS - Win32 Release_TS_inline" (based on "Win32 (x86) Static Library")
-!MESSAGE 
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-RSC=rc.exe
-
-!IF  "$(CFG)" == "ZendTS - Win32 Release_TS"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Output_Dir "Release_TS"
-# PROP BASE Intermediate_Dir "Release_TS"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Output_Dir "Release_TS"
-# PROP Intermediate_Dir "Release_TS"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDebug_TS" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /I "." /D "NDebug_TS" /D ZEND_DEBUG=0 /D _WIN32_WINNT=0x400 /D "_LIB" /D "TSRM_EXPORTS" /D "LIBZEND_EXPORTS" /D "ZTS" /D "ZEND_WIN32" /D "WIN32" /D "_MBCS" /FR /FD /c
-# SUBTRACT CPP /YX
-# ADD BASE RSC /l 0x40d /d "NDebug_TS"
-# ADD RSC /l 0x40d /d "NDebug_TS"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo
-
-!ELSEIF  "$(CFG)" == "ZendTS - Win32 Debug_TS"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Output_Dir "Debug_TS"
-# PROP BASE Intermediate_Dir "Debug_TS"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Output_Dir "Debug_TS"
-# PROP Intermediate_Dir "Debug_TS"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_Debug_TS" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
-# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "." /D "_Debug_TS" /D ZEND_DEBUG=1 /D "_LIB" /D "TSRM_EXPORTS" /D "LIBZEND_EXPORTS" /D "ZTS" /D "ZEND_WIN32" /D "WIN32" /D "_MBCS" /FR /YX /FD /GZ /c
-# ADD BASE RSC /l 0x40d /d "_Debug_TS"
-# ADD RSC /l 0x40d /d "_Debug_TS"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo
-
-!ELSEIF  "$(CFG)" == "ZendTS - Win32 Release_TS_inline"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Output_Dir "ZendTS___Win32_Release_TS_inline"
-# PROP BASE Intermediate_Dir "ZendTS___Win32_Release_TS_inline"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Output_Dir "Release_TS_inline"
-# PROP Intermediate_Dir "Release_TS_inline"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /MD /W3 /GX /O2 /I "." /D "NDebug_TS" /D "_LIB" /D "TSRM_EXPORTS" /D "LIBZEND_EXPORTS" /D "ZTS" /D "WIN32" /D "_MBCS" /D ZEND_DEBUG=0 /FR /FD /c
-# SUBTRACT BASE CPP /YX
-# ADD CPP /nologo /MD /W3 /GX /O2 /I "." /D "NDebug_TS" /D ZEND_DEBUG=0 /D "ZEND_WIN32_FORCE_INLINE" /D _WIN32_WINNT=0x400 /D "_LIB" /D "TSRM_EXPORTS" /D "LIBZEND_EXPORTS" /D "ZTS" /D "ZEND_WIN32" /D "WIN32" /D "_MBCS" /FR /FD /c
-# SUBTRACT CPP /YX
-# ADD BASE RSC /l 0x40d /d "NDebug_TS"
-# ADD RSC /l 0x40d /d "NDebug_TS"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo
-
-!ENDIF 
-
-# Begin Target
-
-# Name "ZendTS - Win32 Release_TS"
-# Name "ZendTS - Win32 Debug_TS"
-# Name "ZendTS - Win32 Release_TS_inline"
-# Begin Group "Source Files"
-
-# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
-# Begin Source File
-
-SOURCE=.\zend.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_alloc.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_API.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_builtin_functions.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_compile.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_constants.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_dynamic_array.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_execute.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_execute_API.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_extensions.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_hash.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_highlight.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_indent.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_ini.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_ini_parser.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_ini_scanner.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=".\zend_language_parser.c"
-# End Source File
-# Begin Source File
-
-SOURCE=".\zend_language_scanner.cpp"
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_list.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_llist.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_opcode.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_operators.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_ptr_stack.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_sprintf.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_stack.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_variables.c
-# End Source File
-# End Group
-# Begin Group "Header Files"
-
-# PROP Default_Filter "h;hpp;hxx;hm;inl"
-# Begin Source File
-
-SOURCE=.\FlexLexer.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\modules.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_alloc.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_API.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_builtin_functions.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_compile.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_config.w32.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_constants.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_dynamic_array.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_errors.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_execute.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_execute_locks.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_extensions.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_fast_cache.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_globals.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_globals_macros.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_hash.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_highlight.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_indent.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_ini.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_ini_parser.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_ini_scanner.h
-# End Source File
-# Begin Source File
-
-SOURCE=".\zend_language_parser.h"
-# End Source File
-# Begin Source File
-
-SOURCE=".\zend_language_scanner.h"
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_list.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_llist.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_operators.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_ptr_stack.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_stack.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\zend_variables.h
-# End Source File
-# End Group
-# Begin Group "Parsers"
-
-# PROP Default_Filter "y"
-# Begin Source File
-
-SOURCE=.\zend_ini_parser.y
-
-!IF  "$(CFG)" == "ZendTS - Win32 Release_TS"
-
-# Begin Custom Build
-InputDir=.
-InputPath=.\zend_ini_parser.y
-
-BuildCmds= \
-	if not "X%CYGWIN%"=="X" bison --output=zend_ini_parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p ini_ zend_ini_parser.y \
-	if "X%CYGWIN%"=="X" bison --output=zend_ini_parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p ini_ zend_ini_parser.y \
-	
-
-"$(InputDir)\zend_ini_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-   $(BuildCmds)
-
-"$(InputDir)\zend_ini_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-   $(BuildCmds)
-# End Custom Build
-
-!ELSEIF  "$(CFG)" == "ZendTS - Win32 Debug_TS"
-
-# Begin Custom Build
-InputDir=.
-InputPath=.\zend_ini_parser.y
-
-BuildCmds= \
-	if not "X%CYGWIN%"=="X" bison --output=zend_ini_parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p ini_ zend_ini_parser.y \
-	if "X%CYGWIN%"=="X" bison --output=zend_ini_parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p ini_ zend_ini_parser.y \
-	
-
-"$(InputDir)\zend_ini_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-   $(BuildCmds)
-
-"$(InputDir)\zend_ini_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-   $(BuildCmds)
-# End Custom Build
-
-!ELSEIF  "$(CFG)" == "ZendTS - Win32 Release_TS_inline"
-
-# Begin Custom Build
-InputDir=.
-InputPath=.\zend_ini_parser.y
-
-BuildCmds= \
-	if not "X%CYGWIN%"=="X" bison --output=zend_ini_parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p ini_ zend_ini_parser.y \
-	if "X%CYGWIN%"=="X" bison --output=zend_ini_parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p ini_ zend_ini_parser.y \
-	
-
-"$(InputDir)\zend_ini_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-   $(BuildCmds)
-
-"$(InputDir)\zend_ini_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-   $(BuildCmds)
-# End Custom Build
-
-!ENDIF 
-
-# End Source File
-# Begin Source File
-
-SOURCE=".\zend_language_parser.y"
-
-!IF  "$(CFG)" == "ZendTS - Win32 Release_TS"
-
-# Begin Custom Build
-InputDir=.
-InputPath=".\zend_language_parser.y"
-
-BuildCmds= \
-	if not "X%CYGWIN%"=="X" bison --output=zend_language_parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p zend zend_language_parser.y \
-	if "X%CYGWIN%"=="X" bison --output=zend_language_parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p zend zend_language_parser.y \
-	
-
-"$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-   $(BuildCmds)
-
-"$(InputDir)\zend_language_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-   $(BuildCmds)
-# End Custom Build
-
-!ELSEIF  "$(CFG)" == "ZendTS - Win32 Debug_TS"
-
-# Begin Custom Build
-InputDir=.
-InputPath=".\zend_language_parser.y"
-
-BuildCmds= \
-	if not "X%CYGWIN%"=="X" bison --output=zend_language_parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p zend zend_language_parser.y \
-	if "X%CYGWIN%"=="X" bison --output=zend_language_parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p zend zend_language_parser.y \
-	
-
-"$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-   $(BuildCmds)
-
-"$(InputDir)\zend_language_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-   $(BuildCmds)
-# End Custom Build
-
-!ELSEIF  "$(CFG)" == "ZendTS - Win32 Release_TS_inline"
-
-# Begin Custom Build
-InputDir=.
-InputPath=".\zend_language_parser.y"
-
-BuildCmds= \
-	if not "X%CYGWIN%"=="X" bison --output=zend_language_parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p zend zend_language_parser.y \
-	if "X%CYGWIN%"=="X" bison --output=zend_language_parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p zend zend_language_parser.y \
-	
-
-"$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-   $(BuildCmds)
-
-"$(InputDir)\zend_language_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-   $(BuildCmds)
-# End Custom Build
-
-!ENDIF 
-
-# End Source File
-# End Group
-# Begin Group "Scanners"
-
-# PROP Default_Filter "l"
-# Begin Source File
-
-SOURCE=.\zend_ini_scanner.l
-
-!IF  "$(CFG)" == "ZendTS - Win32 Release_TS"
-
-# Begin Custom Build
-InputPath=.\zend_ini_scanner.l
-
-"zend_ini_scanner.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-	flex -+ -B -i -Sflex.skl -Pini_ -ozend_ini_scanner.cpp zend_ini_scanner.l
-
-# End Custom Build
-
-!ELSEIF  "$(CFG)" == "ZendTS - Win32 Debug_TS"
-
-# Begin Custom Build
-InputPath=.\zend_ini_scanner.l
-
-"zend_ini_scanner.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-	flex -+ -B -i -Sflex.skl -Pini_ -ozend_ini_scanner.cpp zend_ini_scanner.l
-
-# End Custom Build
-
-!ELSEIF  "$(CFG)" == "ZendTS - Win32 Release_TS_inline"
-
-# Begin Custom Build
-InputPath=.\zend_ini_scanner.l
-
-"zend_ini_scanner.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-	flex -+ -B -i -Sflex.skl -Pini_ -ozend_ini_scanner.cpp zend_ini_scanner.l
-
-# End Custom Build
-
-!ENDIF 
-
-# End Source File
-# Begin Source File
-
-SOURCE=".\zend_language_scanner.l"
-
-!IF  "$(CFG)" == "ZendTS - Win32 Release_TS"
-
-# Begin Custom Build
-InputPath=".\zend_language_scanner.l"
-
-"zend_language_scanner.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-	flex -+ -B -i -Sflex.skl -Pzend -ozend_language_scanner.cpp zend_language_scanner.l
-
-# End Custom Build
-
-!ELSEIF  "$(CFG)" == "ZendTS - Win32 Debug_TS"
-
-# Begin Custom Build
-InputPath=".\zend_language_scanner.l"
-
-"zend_language_scanner.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-	flex -+ -B -i -Sflex.skl -Pzend -ozend_language_scanner.cpp zend_language_scanner.l
-
-# End Custom Build
-
-!ELSEIF  "$(CFG)" == "ZendTS - Win32 Release_TS_inline"
-
-# Begin Custom Build
-InputPath=".\zend_language_scanner.l"
-
-"zend_language_scanner.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-	flex -+ -B -i -Sflex.skl -Pzend -ozend_language_scanner.cpp zend_language_scanner.l
-
-# End Custom Build
-
-!ENDIF 
-
-# End Source File
-# End Group
-# Begin Group "Text Files"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=.\LICENSE
-# End Source File
-# Begin Source File
-
-SOURCE=.\ZEND_BUGS
-# End Source File
-# Begin Source File
-
-SOURCE=.\ZEND_CHANGES
-# End Source File
-# End Group
-# Begin Group "Resources"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=.\zend.ico
-# End Source File
-# End Group
-# End Target
-# End Project
@@ -1,14 +1,46 @@
+#undef HAVE_CLASS_ISTDIOSTREAM
+
 #define ZEND_API
-#define ZEND_DLEXPORT

@TOP@

+/* This is the default configuration file to read */
+#define USE_CONFIG_FILE 1
+
+/* these are defined by automake */
+#undef PACKAGE
+#undef VERSION
+
+/* define uint by configure if it is missed (QNX and BSD derived) */
 #undef uint
+
+/* define ulong by configure if it is missed (most probably is) */
 #undef ulong

+/* Undefine if you want stricter XML/SGML compliance by default */
+/* (this disables "<?expression?>" by default) */
+#define T_DEFAULT_SHORT_OPEN_TAG 1
+
+/* Define both of these if you want the bundled REGEX library */
+#define REGEX 0
+#define HSREGEX 0
+
+#undef ZEND_DEBUG
+
+/* Define if you want to enable bc style precision math support */
+#define WITH_BCMATH 0
+
 /* Define if you want to enable memory limit support */
 #define MEMORY_LIMIT 0

+/* Define if you have broken sprintf function like SunOS 4 */
+#define BROKEN_SPRINTF 0
+
+/* Define to compile Zend thread safe */
+#undef ZTS
+
+#undef HAVE_LIBDL
+
@BOTTOM@

 #ifdef HAVE_STDLIB_H
@@ -25,41 +57,30 @@
 # include <strings.h>
 #endif

+/* Define if you have stdiostream.h */
+#undef HAVE_STDIOSTREAM_H
+
+#ifdef HAVE_DLFCN_H
+# include <dlfcn.h>
+#endif
+
+#if defined(HAVE_LIBDL) && defined(RTLD_NOW)
+# define DL_LOAD(libname)	dlopen(libname, RTLD_NOW)
+# define DL_UNLOAD		dlclose
+# define DL_FETCH_SYMBOL	dlsym
+# define DL_HANDLE		void *
+# define ZEND_EXTENSIONS_SUPPORT 1
+#else
+# define DL_HANDLE		void *
+# define ZEND_EXTENSIONS_SUPPORT 0
+#endif
+
 #if ZEND_BROKEN_SPRINTF
 int zend_sprintf(char *buffer, const char *format, ...);
 #else
 # define zend_sprintf sprintf
 #endif

-#include <math.h>
-
-#ifdef HAVE_ISNAN
-#define zend_isnan(a) isnan(a)
-#elif defined(NAN)
-#define zend_isnan(a) (((a)==NAN)?1:0)
-#else
-#define zend_isnan(a) 0
-#endif
-
-#ifdef HAVE_ISINF
-#define zend_isinf(a) isinf(a)
-#elif defined(INFINITY)
-/* Might not work, but is required by ISO C99 */
-#define zend_isinf(a) (((a)==INFINITY)?1:0)
-#else
-#define zend_isinf(a) 0
-#endif
-
-#ifdef HAVE_FINITE
-#define zend_finite(a) finite(a)
-#elif defined(HAVE_ISFINITE) || defined(isfinite)
-#define zend_finite(a) isfinite(a)
-#elif defined(fpclassify)
-#define zend_finite(a) ((fpclassify((a))!=FP_INFINITE&&fpclassify((a))!=FP_NAN)?1:0)
-#else
-#define zend_finite(a) (zend_isnan(a) ? 0 : zend_isinf(a) ? 0 : 1)
-#endif
-
 /*
 * Local variables:
 * tab-width: 4
@@ -2,43 +2,21 @@ dnl $Id$
 dnl
 dnl This file contains local autoconf functions.

-AC_DEFUN(ZEND_FP_EXCEPT,[
-  AC_CACHE_CHECK(whether fp_except is defined, ac_cv_type_fp_except,[
-    AC_TRY_COMPILE([
-#include <floatingpoint.h>
-],[
-fp_except x = (fp_except) 0;
-],[
-     ac_cv_type_fp_except=yes
-],[
-     ac_cv_type_fp_except=no
-],[
-     ac_cv_type_fp_except=no
-])])
-  if test "$ac_cv_type_fp_except" = "yes"; then
-    AC_DEFINE(HAVE_FP_EXCEPT, 1, [whether floatingpoint.h defines fp_except])
-  fi
-])
-
 dnl
 dnl Check for broken sprintf()
 dnl
 AC_DEFUN(AC_ZEND_BROKEN_SPRINTF,[
-  AC_CACHE_CHECK(whether sprintf is broken, ac_cv_broken_sprintf,[
-    AC_TRY_RUN([main() {char buf[20];exit(sprintf(buf,"testing 123")!=11); }],[
-      ac_cv_broken_sprintf=no
-    ],[
-      ac_cv_broken_sprintf=yes
-    ],[
-      ac_cv_broken_sprintf=no
-    ])
+  AC_MSG_CHECKING([for broken sprintf])
+  AC_TRY_RUN([main() { char buf[20]; exit (sprintf(buf,"testing 123")!=11); }],[
+    AC_DEFINE(ZEND_BROKEN_SPRINTF,0)
+    AC_MSG_RESULT(ok)
+  ],[
+    AC_DEFINE(ZEND_BROKEN_SPRINTF,1)
+    AC_MSG_RESULT(broken)
+  ],[
+    AC_DEFINE(ZEND_BROKEN_SPRINTF,0)
+    AC_MSG_RESULT(cannot check, guessing ok)
  ])
-  if test "$ac_cv_broken_sprintf" = "yes"; then
-    ac_result=1
-  else
-    ac_result=0
-  fi
-  AC_DEFINE_UNQUOTED(ZEND_BROKEN_SPRINTF, $ac_result, [Whether sprintf is broken])
 ])

 AC_DEFUN(AM_SET_LIBTOOL_VARIABLE,[
@@ -2,26 +2,52 @@ 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
-AC_PROG_CC
-AM_PROG_LEX
-AM_PROG_CC_STDC
 ZEND_VERSION=$VERSION

 dnl We want this one before the checks, so the checks can modify CFLAGS.
 test -z "$CFLAGS" && auto_cflags=1

-sinclude(Zend.m4)
-
-LIBZEND_BASIC_CHECKS
+dnl Checks for programs.
+AC_PROG_YACC
+if test "$YACC" != "bison -y"; then
+    AC_MSG_WARN(You will need bison if you want to regenerate the Zend parser.)
+else
+    AC_MSG_CHECKING(bison version)
+    set `bison --version| sed -e 's/^GNU Bison version //' -e 's/\./ /'`
+    if test "$1" = "1" -a "$2" -lt "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
+AC_PROG_CC
+if test "$enable_thread_safety" = "yes" ; then
+AC_PROG_CXX
+fi
+AC_PROG_CC_C_O
+AM_PROG_LEX

 AM_PROG_LIBTOOL
 if test "$enable_debug" != "yes"; then
  AM_SET_LIBTOOL_VARIABLE([--silent])
 fi
+AM_PROG_CC_STDC
+AC_C_INLINE
+
+dnl Hack to work around a Mac OS X cpp problem
+dnl Known versions needing this workaround are 5.3 and 5.4
+if test "$ac_cv_prog_gcc" = "yes" -a "`uname -s`" = "Rhapsody"; then
+        CPPFLAGS="$CPPFLAGS -traditional-cpp"
+fi
+
+dnl Ugly hack to get around a problem with gcc on AIX.
+if test "$CC" = "gcc" -a "$ac_cv_prog_cc_g" = "yes" -a \
+   "`uname -sv`" = "AIX 4"; then
+	CFLAGS=`echo $CFLAGS | sed -e 's/-g//'`
+fi

 dnl
 dnl Check for /usr/pkg/{lib,include} which is where NetBSD puts binary
@@ -32,8 +58,147 @@ if test -d /usr/pkg/include -a -d /usr/pkg/lib ; then
       LDFLAGS="$LDFLAGS -L/usr/pkg/lib"
 fi

-LIBZEND_ENABLE_DEBUG
-LIBZEND_OTHER_CHECKS
+AC_CHECK_LIB(c, dlopen, [
+ # fake it
+ AC_DEFINE(HAVE_LIBDL) ], [
+ AC_CHECK_LIB(dl, dlopen, [
+  LIBS="-ldl $LIBS"
+  AC_DEFINE(HAVE_LIBDL) ], []) ])
+
+dnl Checks for header files.
+AC_HEADER_STDC
+
+dnl QNX requires unix.h to allow functions in libunix to work properly
+AC_CHECK_HEADERS(limits.h malloc.h string.h unistd.h stdarg.h sys/types.h signal.h unix.h dlfcn.h)
+
+if test "$enable_thread_safety" = "yes" ; then
+dnl C++ specific header files
+AC_LANG_CPLUSPLUS
+AC_CHECK_HEADER(stdiostream.h, [ AC_DEFINE(HAVE_STDIOSTREAM_H) ])
+AC_LANG_C
+fi
+
+dnl Checks for types
+AC_TYPE_SIZE_T
+AC_TYPE_SIGNAL
+
+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)
+AC_ZEND_BROKEN_SPRINTF
+
+AC_MSG_CHECKING(whether to include debugging symbols)
+AC_ARG_ENABLE(debug,
+[  --disable-debug         Compile without debugging symbols],
+[
+  if test "$enableval" = "yes"; then
+    AC_MSG_RESULT(yes)
+    AC_DEFINE(ZEND_DEBUG,1)
+    DEBUG_CFLAGS="-g"
+    test -n "$GCC" && DEBUG_CFLAGS="$DEBUG_CFLAGS -Wall"
+    test -n "$GCC" && test "$USE_MAINTAINER_MODE" = "yes" && \
+      DEBUG_CFLAGS="$DEBUG_CFLAGS -Wmissing-prototypes -Wstrict-prototypes -Wmissing-declarations"
+  else
+    AC_MSG_RESULT(no)
+    AC_DEFINE(ZEND_DEBUG,0)
+    DEBUG_CFLAGS=""
+  fi
+],[
+  AC_MSG_RESULT(yes)
+  AC_DEFINE(ZEND_DEBUG,1)
+  DEBUG_CFLAGS="-g"
+]) 
+AC_SUBST(DEBUG_CFLAGS)
+CFLAGS="$CFLAGS $DEBUG_CFLAGS"
+
+RESULT=yes
+AC_MSG_CHECKING(whether to enable inline)
+AC_ARG_ENABLE(inline,
+[  --disable-inline        Disable the inline specifier],
+[
+  if test "$enableval" = "no"; then
+    RESULT=no
+  fi
+])
+AC_MSG_RESULT($RESULT)
+
+if test "$RESULT" = "yes"; then
+  AC_C_INLINE
+else
+  AC_DEFINE(inline, [])
+fi
+
+AC_MSG_CHECKING(whether to enable a memory limit)
+AC_ARG_ENABLE(memory-limit,
+[  --enable-memory-limit   Compile with memory limit support. ],
+[
+  if test "$enableval" = "yes"; then
+    AC_DEFINE(MEMORY_LIMIT, 1)
+    AC_MSG_RESULT(yes)
+  else
+    AC_DEFINE(MEMORY_LIMIT, 0)
+    AC_MSG_RESULT(no)
+  fi
+],[
+  AC_DEFINE(MEMORY_LIMIT, 0)
+  AC_MSG_RESULT(no)
+]) 
+
+
+ZEND_SCANNER_TYPE=c
+dnl Sigh. This will probably break automake's automatic dependencies..
+AC_MSG_CHECKING(whether to build Zend thread-safe)
+AC_ARG_ENABLE(thread-safety,
+[  --enable-thread-safety  Whether to build Zend thread-safe.],[
+  if test "$enableval" = "yes"; then
+    AC_DEFINE(ZTS)
+    ZEND_SCANNER_TYPE=cc
+    CPPFLAGS="$CPPFLAGS -I../TSRM"
+    AC_MSG_RESULT(yes)
+  else
+    AC_MSG_RESULT(no)
+  fi
+],[
+  AC_MSG_RESULT(no)
+])
+AC_SUBST(TSRM_DIR)
+AC_SUBST(TSRM_LIB)
+ZEND_SCANNER="libzend_${ZEND_SCANNER_TYPE}.la"
+AC_SUBST(ZEND_SCANNER)
+
+if test "$enable_thread_safety" = "yes" ; then
+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_LANG_SAVE
+AC_LANG_CPLUSPLUS
+AC_MSG_CHECKING(for 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_DEFINE(HAVE_CLASS_ISTDIOSTREAM, 1)
+  AC_MSG_RESULT(yes)
+],[
+  AC_MSG_RESULT(no)
+])
+AC_LANG_RESTORE
+
+fi

 EXTRA_LIBS="$LIBS"
 LIBS=""
@@ -0,0 +1,373 @@
+# Microsoft Developer Studio Project File - Name="libzend" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=libzend - Win32 Debug
+!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 "libzend.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 "libzend.mak" CFG="libzend - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "libzend - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "libzend - Win32 Debug" (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)" == "libzend - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDebug" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "." /D "NDebug" /D "_LIB" /D "TSRM_EXPORTS" /D "LIBZEND_EXPORTS" /D "WIN32" /D "_MBCS" /D ZEND_DEBUG=0 /FR /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x40d /d "NDebug"
+# ADD RSC /l 0x40d /d "NDebug"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ELSEIF  "$(CFG)" == "libzend - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_Debug" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "." /D "_Debug" /D "_LIB" /D "LIBZEND_EXPORTS" /D "TSRM_EXPORTS" /D "WIN32" /D "_MBCS" /D ZEND_DEBUG=1 /FR /YX /FD /GZ /c
+# ADD BASE RSC /l 0x40d /d "_Debug"
+# ADD RSC /l 0x40d /d "_Debug"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ENDIF 
+
+# Begin Target
+
+# Name "libzend - Win32 Release"
+# Name "libzend - Win32 Debug"
+# 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.c"
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_alloc.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_API.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_builtin_functions.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_compile.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_constants.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_execute.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_execute_API.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_extensions.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_hash.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_highlight.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_indent.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_list.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_llist.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_opcode.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_operators.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_ptr_stack.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_sprintf.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_stack.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_variables.c
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=.\FlexLexer.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\modules.h
+# End Source File
+# Begin Source File
+
+SOURCE=".\zend-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
+
+SOURCE=.\zend_alloc.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_API.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_builtin_functions.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_compile.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_config.w32.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_constants.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_errors.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_execute.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_extensions.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_globals.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_hash.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_highlight.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_indent.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_list.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_llist.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_operators.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_ptr_stack.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_stack.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_variables.h
+# End Source File
+# End Group
+# Begin Group "Parsers"
+
+# PROP Default_Filter "y"
+# Begin Source File
+
+SOURCE=".\zend-parser.y"
+
+!IF  "$(CFG)" == "libzend - Win32 Release"
+
+# Begin Custom Build
+InputDir=.
+InputPath=".\zend-parser.y"
+
+BuildCmds= \
+	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-parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+
+"$(InputDir)\zend-parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+# End Custom Build
+
+!ELSEIF  "$(CFG)" == "libzend - Win32 Debug"
+
+# Begin Custom Build
+InputDir=.
+InputPath=".\zend-parser.y"
+
+BuildCmds= \
+	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-parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+
+"$(InputDir)\zend-parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+# End Custom Build
+
+!ENDIF 
+
+# End Source File
+# End Group
+# Begin Group "Scanners"
+
+# PROP Default_Filter "l"
+# Begin Source File
+
+SOURCE=".\zend-scanner.l"
+
+!IF  "$(CFG)" == "libzend - Win32 Release"
+
+# Begin Custom Build
+InputPath=".\zend-scanner.l"
+
+"zend-scanner.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	flex -i -Pzend -ozend-scanner.c zend-scanner.l
+
+# End Custom Build
+
+!ELSEIF  "$(CFG)" == "libzend - Win32 Debug"
+
+# Begin Custom Build
+InputPath=".\zend-scanner.l"
+
+"zend-scanner.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	flex -i -Pzend -ozend-scanner.c zend-scanner.l
+
+# End Custom Build
+
+!ENDIF 
+
+# End Source File
+# End Group
+# Begin Group "Text Files"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\ZEND_BUGS
+# End Source File
+# Begin Source File
+
+SOURCE=.\ZEND_CHANGES
+# End Source File
+# Begin Source File
+
+SOURCE=.\ZEND_TODO
+# End Source File
+# End Group
+# Begin Group "Resources"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\zend.ico
+# End Source File
+# End Group
+# End Target
+# End Project
@@ -0,0 +1,377 @@
+# Microsoft Developer Studio Project File - Name="libzendts" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=libzendts - 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 "libzendts.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 "libzendts.mak" CFG="libzendts - Win32 Debug_TS"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "libzendts - Win32 Release_TS" (based on "Win32 (x86) Static Library")
+!MESSAGE "libzendts - Win32 Debug_TS" (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)" == "libzendts - Win32 Release_TS"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Output_Dir "Release_TS"
+# PROP BASE Intermediate_Dir "Release_TS"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Output_Dir "Release_TS"
+# PROP Intermediate_Dir "Release_TS"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDebug_TS" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "." /D "NDebug_TS" /D "_LIB" /D "TSRM_EXPORTS" /D "LIBZEND_EXPORTS" /D "ZTS" /D "WIN32" /D "_MBCS" /D ZEND_DEBUG=0 /FR /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x40d /d "NDebug_TS"
+# ADD RSC /l 0x40d /d "NDebug_TS"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ELSEIF  "$(CFG)" == "libzendts - Win32 Debug_TS"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Output_Dir "Debug_TS"
+# PROP BASE Intermediate_Dir "Debug_TS"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Output_Dir "Debug_TS"
+# PROP Intermediate_Dir "Debug_TS"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_Debug_TS" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "." /D "_Debug_TS" /D "_LIB" /D "LIBZEND_EXPORTS" /D "TSRM_EXPORTS" /D "WIN32" /D "_MBCS" /D "ZTS" /D ZEND_DEBUG=1 /FR /YX /FD /GZ /c
+# ADD BASE RSC /l 0x40d /d "_Debug_TS"
+# ADD RSC /l 0x40d /d "_Debug_TS"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ENDIF 
+
+# Begin Target
+
+# Name "libzendts - Win32 Release_TS"
+# Name "libzendts - Win32 Debug_TS"
+# 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
+
+SOURCE=.\zend_alloc.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_API.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_builtin_functions.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_compile.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_constants.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_execute.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_execute_API.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_extensions.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_hash.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_highlight.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_indent.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_list.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_llist.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_opcode.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_operators.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_ptr_stack.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_sprintf.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_stack.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_variables.c
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=.\FlexLexer.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\modules.h
+# End Source File
+# Begin Source File
+
+SOURCE=".\zend-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
+
+SOURCE=.\zend_alloc.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_API.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_builtin_functions.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_compile.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_config.w32.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_constants.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_errors.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_execute.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_extensions.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_globals.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_globals_macros.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_hash.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_highlight.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_indent.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_list.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_llist.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_operators.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_ptr_stack.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_stack.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_variables.h
+# End Source File
+# End Group
+# Begin Group "Parsers"
+
+# PROP Default_Filter "y"
+# Begin Source File
+
+SOURCE=".\zend-parser.y"
+
+!IF  "$(CFG)" == "libzendts - Win32 Release_TS"
+
+# Begin Custom Build
+InputDir=.
+InputPath=".\zend-parser.y"
+
+BuildCmds= \
+	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-parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+
+"$(InputDir)\zend-parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+# End Custom Build
+
+!ELSEIF  "$(CFG)" == "libzendts - Win32 Debug_TS"
+
+# Begin Custom Build
+InputDir=.
+InputPath=".\zend-parser.y"
+
+BuildCmds= \
+	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-parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+
+"$(InputDir)\zend-parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+# End Custom Build
+
+!ENDIF 
+
+# End Source File
+# End Group
+# Begin Group "Scanners"
+
+# PROP Default_Filter "l"
+# Begin Source File
+
+SOURCE=".\zend-scanner.l"
+
+!IF  "$(CFG)" == "libzendts - Win32 Release_TS"
+
+# Begin Custom Build
+InputPath=".\zend-scanner.l"
+
+"zend-scanner.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	flex -+ -i -Sflex.skl -Pzend -ozend-scanner.cpp zend-scanner.l
+
+# End Custom Build
+
+!ELSEIF  "$(CFG)" == "libzendts - Win32 Debug_TS"
+
+# Begin Custom Build
+InputPath=".\zend-scanner.l"
+
+"zend-scanner.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	flex -+ -B -i -Sflex.skl -Pzend -ozend-scanner.cpp zend-scanner.l
+
+# End Custom Build
+
+!ENDIF 
+
+# End Source File
+# End Group
+# Begin Group "Text Files"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\LICENSE
+# End Source File
+# Begin Source File
+
+SOURCE=.\ZEND_BUGS
+# End Source File
+# Begin Source File
+
+SOURCE=.\ZEND_CHANGES
+# End Source File
+# End Group
+# Begin Group "Resources"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\zend.ico
+# End Source File
+# End Group
+# End Target
+# End Project
@@ -0,0 +1,665 @@
+%{
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.91 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_91.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"
+#include "zend_variables.h"
+#include "zend_operators.h"
+
+
+#define YYERROR_VERBOSE
+
+%}
+
+%pure_parser
+%expect 4
+
+%left T_INCLUDE T_EVAL
+%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 XT_OR_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
+%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 '@'
+%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_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_REQUIRE
+%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_HEREDOC
+%token T_DOLLAR_OPEN_CURLY_BRACES
+%token T_CURLY_OPEN
+%token T_PAAMAYIM_NEKUDOTAYIM
+%token T_PHP_TRACK_VARS
+
+%% /* Rules */
+
+top_statement_list:	
+		top_statement_list  { do_extended_info(CLS_C); } top_statement { ELS_FETCH(); 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 { ELS_FETCH(); HANDLE_INTERACTIVE(); }
+	|	/* empty */
+;
+
+
+inner_statement:
+		statement
+	|	declaration_statement
+;
+
+
+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 '(' expr ')' ';' { do_do_while_end(&$1, &$6 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_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 CLS_CC); }
+	|	T_RETURN expr ';'		{ do_return(&$2 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_REQUIRE expr ';'			{ if ($2.op_type==IS_CONST && $2.u.constant.type==IS_STRING) { require_filename($2.u.constant.value.str.val CLS_CC); zval_dtor(&$2.u.constant); } else { do_include_or_eval(ZEND_INCLUDE, &$$, &$2 CLS_CC); } }
+	|	T_UNSET '(' r_cvar ')' ';' { do_unset(&$3 CLS_CC); }
+	|	T_FOREACH '(' expr T_AS { do_foreach_begin(&$1, &$3, &$2, &$4 CLS_CC); } w_cvar foreach_optional_arg ')' { do_foreach_cont(&$6, &$7, &$4 CLS_CC); } foreach_statement { do_foreach_end(&$1, &$2 CLS_CC); }
+	|	';'		/* empty statement */
+;
+
+
+declaration_statement:
+		T_FUNCTION { $1.u.opline_num = CG(zend_lineno); } T_STRING { do_begin_function_declaration(&$1, &$3, 0 CLS_CC); }
+			'(' parameter_list ')' '{' inner_statement_list '}' { do_end_function_declaration(&$1 CLS_CC); }
+	|	T_OLD_FUNCTION { $1.u.opline_num = CG(zend_lineno); } T_STRING  { do_begin_function_declaration(&$1, &$3, 0 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 ';'
+;
+
+
+switch_case_list:
+		'{' case_list '}'					{ $$ = $2; }
+	|	'{' ';' case_list '}'				{ $$ = $3; }
+	|	':' case_list T_ENDSWITCH ';'			{ $$ = $2; }
+	|	':' ';' case_list T_ENDSWITCH ';'		{ $$ = $3; }
+;
+
+
+case_list:
+		/* empty */	{ $$.u.opline_num = -1; }
+	|	case_list T_CASE expr case_separator { do_case_before_statement(&$1, &$2, &$3 CLS_CC); } inner_statement_list { do_case_after_statement(&$$, &$2 CLS_CC); }
+	|	case_list T_DEFAULT case_separator { do_default_before_statement(&$1, &$2 CLS_CC); } inner_statement_list { do_case_after_statement(&$$, &$2 CLS_CC); }
+;
+
+
+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); }
+	|	T_VARIABLE '=' T_UNSET 		{ 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, &$$, NULL, 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); }
+	|	non_empty_parameter_list ',' T_VARIABLE '=' T_UNSET	 	{ znode tmp;  fetch_simple_variable(&tmp, &$3, 0 CLS_CC); $$=$1; $$.u.constant.value.lval++; do_receive_arg(ZEND_RECV_INIT, &tmp, &$$, NULL, 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); } T_STRING { do_begin_function_declaration(&$1, &$3, 1 CLS_CC); } '(' 
+			parameter_list ')' '{' inner_statement_list '}' { do_end_function_declaration(&$1 CLS_CC); }
+	|	T_OLD_FUNCTION { $1.u.opline_num = CG(zend_lineno); } T_STRING { do_begin_function_declaration(&$1, &$3, 1 CLS_CC); }
+			parameter_list '(' inner_statement_list ')' ';' { do_end_function_declaration(&$1 CLS_CC); }
+
+;
+
+
+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); }
+	|	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 XT_OR_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_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); }
+	|	T_STRING	'(' { do_extended_fcall_begin(CLS_C); $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); }
+	|	r_cvar '(' { do_extended_fcall_begin(CLS_C); 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);}
+	|	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_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); }
+;
+
+
+exit_expr:
+		/* empty */		{ $$.op_type = IS_UNUSED; }	
+	|	'(' ')'			{ $$.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; }
+;
+
+
+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_HEREDOC encaps_list T_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	{ $$ = $1; }
+;
+
+
+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; }
+;
+
+
+
+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:
+		dim_list ']' { $$ = $1; }
+	|	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_list:
+		dim_list ']' '[' dim_offset	{ fetch_array_dim(&$$, &$1, &$4 CLS_CC); }
+	|	compound_variable  { do_fetch_globals(&$1 CLS_CC); do_begin_variable_parse(CLS_C); } '[' dim_offset		{ fetch_array_begin(&$$, &$1, &$4 CLS_CC); }
+;
+
+
+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:
+		scalar_object_property		{ znode tmp_znode;  do_pop_object(&tmp_znode CLS_CC);  do_fetch_property(&$$, &tmp_znode, &$1 CLS_CC); }
+	|	object_dim_list ']' { $$ = $1; }
+;
+
+scalar_object_property:
+		T_STRING			{ $$ = $1; }
+	|	'{' expr '}'	{ $$ = $2; }
+	|	cvar_without_objects { do_end_variable_parse(BP_VAR_R, 0 CLS_CC); $$ = $1; }
+;
+
+
+object_dim_list:
+		object_dim_list ']' '[' dim_offset { fetch_array_dim(&$$, &$1, &$4 CLS_CC); }
+	|	T_STRING { znode tmp_znode, res;  do_pop_object(&tmp_znode CLS_CC);  do_fetch_property(&res, &tmp_znode, &$1 CLS_CC);  $1 = res; } '[' dim_offset { fetch_array_dim(&$$, &$1, &$4 CLS_CC); }
+;
+
+
+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:
+		w_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	{ $$ = $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.chval = '['; do_add_char(&$$, &$1, &$2 CLS_CC); }
+	|	encaps_list ']'		{ $2.u.constant.value.chval = ']'; do_add_char(&$$, &$1, &$2 CLS_CC); }
+	|	encaps_list '{'		{ $2.u.constant.value.chval = '{'; do_add_char(&$$, &$1, &$2 CLS_CC); }
+	|	encaps_list '}'		{ $2.u.constant.value.chval = '}'; do_add_char(&$$, &$1, &$2 CLS_CC); }
+	|	encaps_list T_OBJECT_OPERATOR  { znode tmp;  $2.u.constant.value.chval = '-';  do_add_char(&tmp, &$1, &$2 CLS_CC);  $2.u.constant.value.chval = '>'; 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_EVAL '(' expr ')' 	{ do_include_or_eval(ZEND_EVAL, &$$, &$3 CLS_CC); }
+;
+
+
+%%
+
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -18,8 +18,8 @@
 */


-#ifndef ZEND_SCANNER_H
-#define ZEND_SCANNER_H
+#ifndef _LANGUAGE_SCANNER_H
+#define _LANGUAGE_SCANNER_H

 #ifdef ZTS
 class ZendFlexLexer : public yyFlexLexer
@@ -33,24 +33,20 @@ public:
 #endif	/* ZTS */


-typedef struct _zend_lex_state {
 #ifndef ZTS
+typedef struct _zend_lex_state {
 	YY_BUFFER_STATE buffer_state;
 	int state;
-	FILE *in;
-#else
-	ZendFlexLexer *ZFL;
-	istream *input_file;
-#endif
+	uint return_offset;
 	uint lineno;
+	FILE *in;
 	char *filename;
 } zend_lex_state;
-
-
-void zend_fatal_scanner_error(char *);
-inline void restore_lexical_state(zend_lex_state * CLS_DC);
-BEGIN_EXTERN_C()
-int zend_compare_file_handles(zend_file_handle *fh1, zend_file_handle *fh2);
-END_EXTERN_C()
+#else
+typedef struct _zend_lex_state {
+	ZendFlexLexer *ZFL;
+	istream *input_file;
+} zend_lex_state;
+#endif

 #endif
@@ -4,12 +4,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -33,17 +33,17 @@

 %{

-#ifdef ZEND_WIN32
+#if WIN32|WINNT
+#include <winsock.h>
 #include <io.h>
 #endif

 #include <errno.h>
-#include <limits.h>
+
 #include "zend.h"
 #include "zend_alloc.h"
-#include "zend_language_parser.h"
 #include "zend_compile.h"
-#include "zend_language_scanner.h"
+#include "zend-scanner.h"
 #include "zend_highlight.h"
 #include "zend_constants.h"
 #include "zend_variables.h"
@@ -57,7 +57,7 @@
 # ifdef HAVE_STDIOSTREAM_H
 #  include <stdiostream.h>
 # endif
-# ifdef ZEND_WIN32
+# if WIN32||WINNT
 #  include <strstrea.h>
 # else
 #  include <strstream.h>
@@ -77,7 +77,6 @@
 #else
 #define YY_DECL int lex_scan(zval *zendlval CLS_DC)
 #endif
-
 #define ECHO { ZEND_WRITE( yytext, yyleng ); }

 #ifdef ZTS
@@ -90,10 +89,9 @@
 class istdiostream : public istream
 {
 private:
-	stdiobuf _file;
+  stdiobuf _file;
 public:
-	istdiostream (FILE* __f) : istream(), _file(__f) { init(&_file); }
-	stdiobuf* rdbuf()/* const */ { return &_file; }
+  istdiostream (FILE* __f) : istream(), _file(__f) { init(&_file); }
 };
 #endif

@@ -150,12 +148,12 @@ static inline void save_lexical_state(zend_lex_state *lex_state CLS_DC)
 #ifndef ZTS
 	memcpy(&lex_state->buffer_state,&YY_CURRENT_BUFFER,sizeof(YY_BUFFER_STATE));
 	lex_state->in = yyin;
+	lex_state->lineno = CG(zend_lineno);
 	lex_state->state = YYSTATE;
+	lex_state->filename = zend_get_compiled_filename();
 #else
 	lex_state->ZFL = CG(ZFL);
 #endif
-	lex_state->filename = zend_get_compiled_filename(CLS_C);
-	lex_state->lineno = CG(zend_lineno);
 }


@@ -172,106 +170,60 @@ inline void restore_lexical_state(zend_lex_state *lex_state CLS_DC)
 		
 	yy_delete_buffer(original_buffer_state);
 	yyin = lex_state->in;
+	CG(zend_lineno) = lex_state->lineno;
 	BEGIN(lex_state->state);
+	zend_restore_compiled_filename(lex_state->filename);
 #else
 	delete((ZendFlexLexer *) CG(ZFL));
 	CG(ZFL) = lex_state->ZFL;
 #endif
-	CG(zend_lineno) = lex_state->lineno;
-	zend_restore_compiled_filename(lex_state->filename);
 }


 BEGIN_EXTERN_C()


-ZEND_API void zend_file_handle_dtor(zend_file_handle *fh)
+ZEND_API void zend_open_file_dtor(void *f)
 {
-	switch (fh->type) {
-		case ZEND_HANDLE_FP:
-			fclose(fh->handle.fp);
-			break;
-		case ZEND_HANDLE_FILENAME:
-			/* We're only supposed to get here when destructing the used_files hash,
-			 * which doesn't really contain open files, but references to their names/paths
-			 */
-			break;
 #ifdef ZTS
-		case ZEND_HANDLE_FSTREAM:
-			delete ((ifstream *) fh->handle.is);
-			break;
-		case ZEND_HANDLE_STDIOSTREAM:
-			istdiostream *pstdiostream = (istdiostream *) fh->handle.is;
-			
-			fclose(pstdiostream->rdbuf()->stdiofile());
-			delete pstdiostream;
-			break;
+	delete *((istream **) f);
+#else
+	fclose(*((FILE **) f));
 #endif
-	}
-	if (fh->opened_path) {
-		efree(fh->opened_path);
-	}
-	if (fh->free_filename && fh->filename) {
-		efree(fh->filename);
-	}
 }


-int zend_compare_file_handles(zend_file_handle *fh1, zend_file_handle *fh2)
+ZEND_API void zend_close_file_handle(zend_file_handle *file_handle CLS_DC)
 {
-	if (fh1->type != fh2->type) {
-		return 0;
-	}
-	switch (fh1->type) {
-		case ZEND_HANDLE_FP:
-			return fh1->handle.fp==fh2->handle.fp;
-			break;
 #ifdef ZTS
-		case ZEND_HANDLE_FSTREAM:
-		case ZEND_HANDLE_STDIOSTREAM:
-			return fh1->handle.is==fh2->handle.is;
-			break;
+	zend_llist_del_element(&CG(open_files), &file_handle->handle.is);
+#else
+	zend_llist_del_element(&CG(open_files), &file_handle->handle.fp);
 #endif
-	}
-	return 0;
-}
-
-
-ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle CLS_DC)
-{
-	zend_llist_del_element(&CG(open_files), file_handle, (int (*)(void *, void *)) zend_compare_file_handles);
 }


 ZEND_API int open_file_for_scanning(zend_file_handle *file_handle CLS_DC)
 {
-	char *file_path=NULL;
-
 #ifndef ZTS
 	switch (file_handle->type) {
 		case ZEND_HANDLE_FILENAME:
-			file_handle->handle.fp = zend_fopen(file_handle->filename, &file_handle->opened_path);
-		    file_path = file_handle->opened_path; 
+			file_handle->handle.fp = zend_fopen(file_handle->filename);
 			break;
 		case ZEND_HANDLE_FD:
-		  /* file_handle->opened_path = NULL; */
 			file_handle->handle.fp = fdopen(file_handle->handle.fd, "r");
 			break;
 		case ZEND_HANDLE_FP:
-		  /* file_handle->opened_path = NULL; */
 			file_handle->handle.fp = file_handle->handle.fp;
 			break;
 	}
 	if (!file_handle->handle.fp) {
 		return FAILURE;
 	}
-	if (!file_path) {
-		file_path = file_handle->filename;
+	if (file_handle->handle.fp != stdin) {
+		zend_llist_add_element(&CG(open_files), &file_handle->handle.fp);
 	}
 	file_handle->type = ZEND_HANDLE_FP;	
-	if (file_handle->handle.fp != stdin) {
-		zend_llist_add_element(&CG(open_files), file_handle);
-	}
 	/* Reset the scanner for scanning the new file */
 	yyin = file_handle->handle.fp;
 	yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
@@ -279,103 +231,104 @@ ZEND_API int open_file_for_scanning(zend_file_handle *file_handle CLS_DC)
 #else
 	switch (file_handle->type) {
 		case ZEND_HANDLE_FD:
-		  /* file_handle->opened_path = NULL; */
 			file_handle->handle.is = new ifstream(file_handle->handle.fd);
-			file_handle->type = ZEND_HANDLE_FSTREAM;
 			break;
 		case ZEND_HANDLE_FILENAME:
 			{
-				file_handle->handle.fp = zend_fopen(file_handle->filename, &file_handle->opened_path);
+				file_handle->handle.fp = zend_fopen(file_handle->filename);
 				if (!file_handle->handle.fp) {
 					return FAILURE;
 				}
 				file_handle->handle.is = new istdiostream(file_handle->handle.fp);
-				file_handle->type = ZEND_HANDLE_STDIOSTREAM;
 				break;
 			}
 		case ZEND_HANDLE_FP:
-		  /* file_handle->opened_path = NULL; */
 			if (file_handle->handle.fp==stdin) {
-				file_handle->handle.is = &cin;
+				file_handle->handle.is = (ifstream *) &cin;
 			} else {
 				if (!file_handle->handle.fp) {
 					return FAILURE;
 				}
 				file_handle->handle.is = new istdiostream(file_handle->handle.fp);
-				file_handle->type = ZEND_HANDLE_STDIOSTREAM;
 			}	
 			break;
 	}
-
-	file_path = file_handle->filename;
-
 	if (file_handle->handle.is->fail()) {
 		delete file_handle->handle.is;
 		return FAILURE;
 	}
 	if (file_handle->handle.is != &cin) {
-		zend_llist_add_element(&CG(open_files), file_handle);
+		zend_llist_add_element(&CG(open_files), &file_handle->handle.is);
 	}
+	file_handle->type = ZEND_HANDLE_ISTREAM;

 	CG(ZFL) = new ZendFlexLexer;
 	CG(ZFL)->switch_streams(file_handle->handle.is, &cout);
 #endif
-	zend_set_compiled_filename(file_path);
+	zend_set_compiled_filename(file_handle->filename);
 	CG(zend_lineno) = 1;
 	return SUCCESS;
 }
 END_EXTERN_C()


-ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type CLS_DC)
+ZEND_API zend_op_array *compile_files(int mark_as_ref CLS_DC, int file_count, ...)
+{
+	va_list files;
+	zend_op_array *op_array;
+
+	va_start(files, file_count);
+	op_array = v_compile_files(mark_as_ref CLS_CC, file_count, files);
+	va_end(files);
+	return op_array;
+}
+
+
+ZEND_API zend_op_array *v_compile_files(int mark_as_ref CLS_DC, int file_count, va_list files)
 {
 	zend_lex_state original_lex_state;
 	zend_op_array *op_array = (zend_op_array *) emalloc(sizeof(zend_op_array));
 	zend_op_array *original_active_op_array = CG(active_op_array);
 	zend_op_array *retval=NULL;
+	zend_file_handle *file_handle;
+	int i;
 	int compiler_result;
-	zend_bool compilation_successful=0;
-	znode retval_znode;
-	zend_bool original_in_compilation = CG(in_compilation);
-
-	retval_znode.op_type = IS_CONST;
-	retval_znode.u.constant.type = IS_LONG;
-	retval_znode.u.constant.value.lval = 1;
-	retval_znode.u.constant.is_ref = 0;
-	retval_znode.u.constant.refcount = 1;
+	int compiled_files=0;

+	init_op_array(op_array, INITIAL_OP_ARRAY_SIZE);
 	save_lexical_state(&original_lex_state CLS_CC);

 	retval = op_array; /* success oriented */
-
-	if (open_file_for_scanning(file_handle CLS_CC)==FAILURE) {
-		if (type==ZEND_REQUIRE) {
-			zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, file_handle->filename);
-			zend_bailout();		
-		} else {
+	for (i=0; i<file_count; i++) {
+		file_handle = va_arg(files, zend_file_handle *);
+		if (!file_handle) {
+			continue;
+		}
+		if (open_file_for_scanning(file_handle CLS_CC)==FAILURE) {
 			zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, file_handle->filename);
+		} else {
+			CG(active_op_array) = op_array;
+			compiler_result = zendparse(CLS_C);
+			zend_close_file_handle(file_handle CLS_CC);
+			restore_lexical_state(&original_lex_state CLS_CC);
+			CG(active_op_array) = original_active_op_array;
+			if (compiler_result==1) { /* parser error */
+				CG(unclean_shutdown) = 1;
+				retval = NULL;
+				break;
+			}
+			compiled_files++;
 		}
-		compilation_successful=0;
-	} else {
-		init_op_array(op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE CLS_CC);
-		CG(in_compilation) = 1;
-		CG(active_op_array) = op_array;
-		compiler_result = zendparse(CLS_C);
-		zend_do_return(&retval_znode, 0 CLS_CC);
-		restore_lexical_state(&original_lex_state CLS_CC);
-		CG(in_compilation) = original_in_compilation;
-		if (compiler_result==1) { /* parser error */
-			CG(unclean_shutdown) = 1;
-			retval = NULL;
-		}
-		compilation_successful=1;
 	}

 	if (retval) {
-		CG(active_op_array) = original_active_op_array;
-		if (compilation_successful) {
+		if (compiled_files>0) {
 			pass_two(op_array);
+			if (mark_as_ref) {
+				pass_include_eval(op_array);
+			}
 		} else {
+			destroy_op_array(op_array);
 			efree(op_array);
 			retval = NULL;
 		}
@@ -384,7 +337,7 @@ ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type CLS
 }


-zend_op_array *compile_filename(int type, zval *filename CLS_DC ELS_DC)
+zend_op_array *compile_filename(zval *filename CLS_DC)
 {
 	zend_file_handle file_handle;
 	zval tmp;
@@ -397,51 +350,36 @@ zend_op_array *compile_filename(int type, zval *filename CLS_DC ELS_DC)
 		filename = &tmp;
 	}
 	file_handle.filename = filename->value.str.val;
-	file_handle.free_filename = 0;
 	file_handle.type = ZEND_HANDLE_FILENAME;
-	file_handle.opened_path = NULL;
-
-
-	retval = zend_compile_file(&file_handle, type CLS_CC);
-	if (retval && file_handle.opened_path) {
-		int dummy = 1;
-		zend_hash_add(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1, (void *)&dummy, sizeof(int), NULL);
-	}
-	zend_destroy_file_handle(&file_handle CLS_CC);
-
+	retval = zend_compile_files(1 CLS_CC, 1, &file_handle);
 	if (filename==&tmp) {
 		zval_dtor(&tmp);
 	}
 	return retval;
 }

-#ifndef ZTS
-static inline int prepare_string_for_scanning(zval *str, char *filename)
-#else
-static inline int prepare_string_for_scanning(zval *str, istrstream **input_stream, char *filename CLS_DC)
-#endif
+
+static inline int prepare_string_for_scanning(zval *str CLS_DC)
 {
 #ifndef ZTS
 	/* enforce two trailing NULLs for flex... */
-	STR_REALLOC(str->value.str.val, str->value.str.len+2);
+	str->value.str.val = (char *) erealloc(str->value.str.val,str->value.str.len+2);

 	str->value.str.val[str->value.str.len+1]=0;

 	yyin=NULL;
 	yy_scan_buffer(str->value.str.val, str->value.str.len+2);
 #else
-	*input_stream = new istrstream(str->value.str.val, str->value.str.len);
+	istrstream *input_stream = new istrstream(str->value.str.val, str->value.str.len);
 	CG(ZFL) = new ZendFlexLexer;

-	CG(ZFL)->switch_streams(*input_stream, &cout);
+	CG(ZFL)->switch_streams(input_stream, &cout);
 #endif
-	zend_set_compiled_filename(filename);
-	CG(zend_lineno) = 1;
 	return SUCCESS;
 }


-zend_op_array *compile_string(zval *source_string, char *filename CLS_DC)
+zend_op_array *compile_string(zval *source_string CLS_DC)
 {
 	zend_lex_state original_lex_state;
 	zend_op_array *op_array = (zend_op_array *) emalloc(sizeof(zend_op_array));
@@ -449,33 +387,24 @@ zend_op_array *compile_string(zval *source_string, char *filename CLS_DC)
 	zend_op_array *retval;
 	zval tmp;
 	int compiler_result;
-	zend_bool original_in_compilation = CG(in_compilation);
-#ifdef ZTS
-	istrstream *input_stream;
-#endif

 	if (source_string->value.str.len==0) {
 		efree(op_array);
 		return NULL;
 	}
-
-	CG(in_compilation) = 1;
-
 	tmp = *source_string;
 	zval_copy_ctor(&tmp);
 	convert_to_string(&tmp);
 	source_string = &tmp;

+	init_op_array(op_array, INITIAL_OP_ARRAY_SIZE);
+	op_array->type = ZEND_EVAL_CODE;
 	save_lexical_state(&original_lex_state CLS_CC);
-#ifndef ZTS
-	if (prepare_string_for_scanning(source_string, filename)==FAILURE) {
-#else
-	if (prepare_string_for_scanning(source_string, &input_stream, filename CLS_CC)==FAILURE) {
-#endif
+	if (prepare_string_for_scanning(source_string CLS_CC)==FAILURE) {
+		destroy_op_array(op_array);
 		efree(op_array);
 		retval = NULL;
 	} else {
-		init_op_array(op_array, ZEND_EVAL_CODE, INITIAL_OP_ARRAY_SIZE CLS_CC);
 		CG(active_op_array) = op_array;
 #ifndef ZTS
 		BEGIN(ST_IN_SCRIPTING);
@@ -484,28 +413,57 @@ zend_op_array *compile_string(zval *source_string, char *filename CLS_DC)
 #endif
 		compiler_result = zendparse(CLS_C);
 		restore_lexical_state(&original_lex_state CLS_CC);
+		CG(active_op_array) = original_active_op_array;
 		
 		if (compiler_result==1) {
-			CG(active_op_array) = original_active_op_array;
 			CG(unclean_shutdown)=1;
 			retval = NULL;
 		} else {
-			zend_do_return(NULL, 0 CLS_CC);
-			CG(active_op_array) = original_active_op_array;
 			pass_two(op_array);
+			pass_include_eval(op_array);
 			retval = op_array;
 		}
 	}
-#ifdef ZTS
-	delete input_stream;
-#endif
 	zval_dtor(&tmp);
-	CG(in_compilation) = original_in_compilation;
 	return retval;
 }


 BEGIN_EXTERN_C()
+int require_filename(char *filename CLS_DC)
+{
+	zend_file_handle file_handle;
+
+	file_handle.type = ZEND_HANDLE_FILENAME;
+	file_handle.filename = filename;
+	if (require_file(&file_handle CLS_CC)==FAILURE) {
+		zend_bailout();
+		return FAILURE; /* will never get here */
+	}
+	return SUCCESS;
+}
+
+
+int require_file(zend_file_handle *file_handle CLS_DC)
+{
+	zend_lex_state original_lex_state;
+	int compiler_result;
+
+	save_lexical_state(&original_lex_state CLS_CC);
+	if (open_file_for_scanning(file_handle CLS_CC)==FAILURE) {
+		zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, file_handle->filename);
+		return FAILURE;
+	}
+	compiler_result = zendparse(CLS_C);
+	zend_close_file_handle(file_handle CLS_CC);
+	restore_lexical_state(&original_lex_state CLS_CC);
+	if (compiler_result==1) {
+		zend_bailout();
+	}
+	return SUCCESS;
+}
+
+
 int highlight_file(char *filename, zend_syntax_highlighter_ini *syntax_highlighter_ini)
 {
 	zend_lex_state original_lex_state;
@@ -514,43 +472,32 @@ int highlight_file(char *filename, zend_syntax_highlighter_ini *syntax_highlight

 	file_handle.type = ZEND_HANDLE_FILENAME;
 	file_handle.filename = filename;
-	file_handle.free_filename = 0;
-	file_handle.opened_path = NULL;
 	save_lexical_state(&original_lex_state CLS_CC);
 	if (open_file_for_scanning(&file_handle CLS_CC)==FAILURE) {
 		zend_message_dispatcher(ZMSG_FAILED_HIGHLIGHT_FOPEN, filename);
 		return FAILURE;
 	}
 	zend_highlight(syntax_highlighter_ini);
-	zend_destroy_file_handle(&file_handle CLS_CC);
+	zend_close_file_handle(&file_handle CLS_CC);
 	restore_lexical_state(&original_lex_state CLS_CC);
 	return SUCCESS;
 }

-int highlight_string(zval *str, zend_syntax_highlighter_ini *syntax_highlighter_ini, char *str_name)
+
+int highlight_string(zval *str, zend_syntax_highlighter_ini *syntax_highlighter_ini)
 {
 	zend_lex_state original_lex_state;
 	zval tmp = *str;
-#ifdef ZTS
-	istrstream *input_stream;
-#endif
 	CLS_FETCH();

 	str = &tmp;
 	zval_copy_ctor(str);
 	save_lexical_state(&original_lex_state CLS_CC);
-#ifndef ZTS
-	if (prepare_string_for_scanning(str, str_name)==FAILURE) {
-#else
-	if (prepare_string_for_scanning(str, &input_stream, str_name CLS_CC)==FAILURE) {
-#endif
+	if (prepare_string_for_scanning(str CLS_CC)==FAILURE) {
 		return FAILURE;
 	}
 	zend_highlight(syntax_highlighter_ini);
 	restore_lexical_state(&original_lex_state CLS_CC);
-#ifdef ZTS
-	delete input_stream;
-#endif
 	zval_dtor(str);
 	return SUCCESS;
 }
@@ -599,6 +546,47 @@ int yyFlexLexer::yylex()

 #endif

+
+/* redefine YY_INPUT to handle urls for win32*/
+#if 0 /*WIN32|WINNT*/
+#define YY_INPUT(buf,result,max_size) \
+	if ( yyin->_tmpfname != "url" ){ \
+	if ( yy_current_buffer->yy_is_interactive ) \
+		{ \
+		int c = '*', n; \
+		for ( n = 0; n < max_size && \
+			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
+			buf[n] = (char) c; \
+		if ( c == '\n' ) \
+			buf[n++] = (char) c; \
+		if ( c == EOF && ferror( yyin ) ) \
+			YY_FATAL_ERROR( "input in flex scanner failed" ); \
+		result = n; \
+		} \
+	else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
+		  && ferror( yyin ) ) \
+		YY_FATAL_ERROR( "input in flex scanner failed" ); \
+	}else{ /* this is a url */ \
+	int recv_char=0,socketd=0; \
+	/*memset(buf,0,max_size);*/ \
+	socketd=yyin->_file; \
+	if ( yy_current_buffer->yy_is_interactive ) \
+		{ \
+		int c = '*', n; \
+		for ( n = 0; n < max_size && \
+			     ( (recv_char=recv( socketd,(char *)&c,1,0 ))) >0 && c != '\n'; ++n ) \
+			buf[n] = (char) c; \
+		if ( c == '\n' ) \
+			buf[n++] = (char) c; \
+		if ( recv_char == SOCKET_ERROR ) \
+			YY_FATAL_ERROR( "input from url in flex scanner failed" ); \
+		result = n; \
+		} \
+	else if ((result = recv( socketd, (char *)buf, max_size, 0)) == SOCKET_ERROR) \
+		  	YY_FATAL_ERROR( "input from url read in flex scanner failed" ); \
+	}
+#endif
+
 %}

 LNUM	[0-9]+
@@ -611,7 +599,6 @@ TABS_AND_SPACES [ \t]*
 TOKENS [;:,.\[\]()|^&+-/*=%!~$<>?@]
 ENCAPSED_TOKENS [\[\]{}$]
 ESCAPED_AND_WHITESPACE [\n\t\r #'.:;,()|^&+-/*=%!~<>?@]+
-ANY_CHAR (.|[\n])

 %option noyylineno
 %option noyywrap
@@ -685,14 +672,6 @@ ANY_CHAR (.|[\n])
 	return T_ENDFOREACH;
 }

-<ST_IN_SCRIPTING>"declare" {
-	return T_DECLARE;
-}
-
-<ST_IN_SCRIPTING>"enddeclare" {
-	return T_ENDDECLARE;
-}
-
 <ST_IN_SCRIPTING>"as" {
 	return T_AS;
 }
@@ -750,7 +729,7 @@ ANY_CHAR (.|[\n])
 	return T_STRING;
 }

-<ST_LOOKING_FOR_PROPERTY>{ANY_CHAR} {
+<ST_LOOKING_FOR_PROPERTY>. {
 	/*unput(yytext[0]);*/
 	yyless(0);
 	yy_pop_state();
@@ -792,10 +771,6 @@ ANY_CHAR (.|[\n])
 	return T_BOOL_CAST;
 }

-<ST_IN_SCRIPTING>"("{TABS_AND_SPACES}("unset"){TABS_AND_SPACES}")" {
-	return T_UNSET_CAST;
-}
-
 <ST_IN_SCRIPTING>"eval" {
 	return T_EVAL;
 }
@@ -804,22 +779,10 @@ ANY_CHAR (.|[\n])
 	return T_INCLUDE;
 }

-<ST_IN_SCRIPTING>"include_once" {
-	return T_INCLUDE_ONCE;
-}
-
 <ST_IN_SCRIPTING>"require" {
 	return T_REQUIRE;
 }

-<ST_IN_SCRIPTING>"require_once" {
-	return T_REQUIRE_ONCE;
-}
-
-<ST_IN_SCRIPTING>"use" {
-	return T_USE;
-}
-
 <ST_IN_SCRIPTING>"global" {
 	return T_GLOBAL;
 }
@@ -864,10 +827,6 @@ ANY_CHAR (.|[\n])
 	return T_IS_IDENTICAL;
 }

-<ST_IN_SCRIPTING>"!==" {
-	return T_IS_NOT_IDENTICAL;
-}
-
 <ST_IN_SCRIPTING>"==" {
 	return T_IS_EQUAL;
 }
@@ -926,7 +885,7 @@ ANY_CHAR (.|[\n])
 }

 <ST_IN_SCRIPTING>"^=" {
-	return T_XOR_EQUAL;
+	return XT_OR_EQUAL;
 }

 <ST_IN_SCRIPTING>"||" {
@@ -993,7 +952,7 @@ ANY_CHAR (.|[\n])
 }


-<ST_LOOKING_FOR_VARNAME>{ANY_CHAR} {
+<ST_LOOKING_FOR_VARNAME>. {
 	/*unput(yytext[0]);*/
 	yyless(0);
 	yy_pop_state();
@@ -1001,7 +960,7 @@ ANY_CHAR (.|[\n])
 }


-<ST_IN_SCRIPTING>{LNUM} {
+<ST_IN_SCRIPTING>{LNUM}|{HNUM} {
 	errno = 0;
 	zendlval->value.lval = strtol(yytext, NULL, 0);
 	if (errno == ERANGE) { /* overflow */
@@ -1014,26 +973,6 @@ ANY_CHAR (.|[\n])
 	}
 }

-<ST_IN_SCRIPTING>{HNUM} {
-	errno = 0;
-	zendlval->value.lval = strtoul(yytext, NULL, 16);
-	if (errno == ERANGE) { /* overflow */
-		/* not trying strtod - it returns trash on 0x-es */
-		zendlval->value.lval = LONG_MAX; /* maximal long */
-		zend_error(E_NOTICE,"Hex number is too big: %s",yytext);
-	} else {
-		if(zendlval->value.lval < 0) {
-			/* maintain consistency with the old way */
-			zendlval->value.dval = (unsigned long) zendlval->value.lval;
-			zendlval->type = IS_DOUBLE;
-			return T_DNUMBER;
-		}
-		zendlval->type = IS_LONG;
-	}
-	zendlval->type = IS_LONG;
-	return T_LNUMBER;
-}
-
 <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>{LNUM}|{HNUM} { /* treat numbers (almost) as strings inside encapsulated strings */
 	zendlval->value.str.val = (char *)estrndup(yytext, yyleng);
 	zendlval->value.str.len = yyleng;
@@ -1054,7 +993,7 @@ ANY_CHAR (.|[\n])
 }

 <ST_IN_SCRIPTING>"__FILE__" {
-	char *filename = zend_get_compiled_filename(CLS_C);
+	char *filename = zend_get_compiled_filename();
 	
 	if (!filename) {
 		filename = "";
@@ -1114,7 +1053,6 @@ ANY_CHAR (.|[\n])
 		zendlval->value.str.len = yyleng;
 		zendlval->type = IS_STRING;
 		BEGIN(ST_IN_SCRIPTING);
-		return T_OPEN_TAG;
 	} else {
 		zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
 		zendlval->value.str.len = yyleng;
@@ -1135,12 +1073,9 @@ ANY_CHAR (.|[\n])


 <INITIAL>"<?php_track_vars?>"([\n]|"\r\n")? {
-	zend_error(E_WARNING, "&lt;?php_track_vars?&gt; is no longer supported - please use the track_vars INI directive instead");
+	zend_message_dispatcher(ZMSG_ENABLE_TRACK_VARS, NULL);
 	HANDLE_NEWLINE(yytext[yyleng-1]);
-	zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
-	zendlval->value.str.len = yyleng;
-	zendlval->type = IS_STRING;
-	return T_INLINE_HTML;
+	return T_PHP_TRACK_VARS;
 }

 <ST_IN_SCRIPTING,ST_DOUBLE_QUOTES,ST_HEREDOC,ST_BACKQUOTE>"$"{LABEL} {
@@ -1182,7 +1117,6 @@ ANY_CHAR (.|[\n])
 }

 <ST_IN_SCRIPTING>"/*" {
-	CG(comment_start_line) = CG(zend_lineno);
 	BEGIN(ST_COMMENT);
 	yymore();
 }
@@ -1213,15 +1147,14 @@ ANY_CHAR (.|[\n])


 <ST_IN_SCRIPTING>"%>"([\n]|"\r\n")? {
+	zendlval->value.str.val = yytext; /* no copying - intentional */
 	zendlval->value.str.len = yyleng;
 	zendlval->type = IS_STRING;
 	HANDLE_NEWLINES(yytext,yyleng);
 	if (CG(asp_tags)) {
 		BEGIN(INITIAL);
-		zendlval->value.str.val = yytext; /* no copying - intentional */
 		return T_CLOSE_TAG;  /* implicit ';' at php-end tag */
 	} else {
-	        zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
 		return T_INLINE_HTML;
 	}
 }
@@ -1366,7 +1299,7 @@ ANY_CHAR (.|[\n])
 	}
 	CG(heredoc) = estrndup(s, CG(heredoc_len));
 	BEGIN(ST_HEREDOC);
-	return T_START_HEREDOC;
+	return T_HEREDOC;
 }
 	

@@ -1401,8 +1334,6 @@ ANY_CHAR (.|[\n])
 	}

 	if (label_len==CG(heredoc_len) && !memcmp(yytext, CG(heredoc), label_len)) {
-		zendlval->value.str.val = estrndup(yytext, yyleng); /* unput destroys yytext */
-		zendlval->value.str.len = yyleng;
 		if (unput_semicolon) {
 			unput(';');
 		}
@@ -1410,7 +1341,7 @@ ANY_CHAR (.|[\n])
 		CG(heredoc)=NULL;
 		CG(heredoc_len)=0;
 		BEGIN(ST_IN_SCRIPTING);
-		return T_END_HEREDOC;
+		return T_HEREDOC;
 	} else {
 		zendlval->value.str.val = (char *)estrndup(yytext, yyleng);
 		zendlval->value.str.len = yyleng;
@@ -1454,7 +1385,7 @@ ANY_CHAR (.|[\n])


 <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"$"[^a-zA-Z_\x7f-\xff{] {
-	zendlval->value.lval = (long) yytext[0];
+	zendlval->value.chval = yytext[0];
 	if (yyleng == 2) {
 		yyless(1);
 		/*unput(yytext[1]);
@@ -1466,12 +1397,12 @@ ANY_CHAR (.|[\n])


 <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>{ENCAPSED_TOKENS} {
-	zendlval->value.lval = (long) yytext[0];
+	zendlval->value.chval = yytext[0];
 	return yytext[0];
 }

 <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"{$" {
-	zendlval->value.lval = (long) yytext[0];
+	zendlval->value.chval = yytext[0];
 	yy_push_state(ST_IN_SCRIPTING);
 	/*unput('$');*/
 	yyless(1);
@@ -1480,54 +1411,54 @@ ANY_CHAR (.|[\n])


 <ST_SINGLE_QUOTE>"\\'" {
-	zendlval->value.lval = (long) '\'';
+	zendlval->value.chval='\'';
 	return T_CHARACTER;
 }

 <ST_SINGLE_QUOTE>"\\\\" {
-	zendlval->value.lval = (long)'\\';
+	zendlval->value.chval='\\';
 	return T_CHARACTER;
 }

 <ST_DOUBLE_QUOTES>"\\\"" {
-	zendlval->value.lval = (long) '"';
+	zendlval->value.chval='"';
 	return T_CHARACTER;
 }

 <ST_BACKQUOTE>"\\`" {
-	zendlval->value.lval = (long) '`';
+	zendlval->value.chval='`';
 	return T_CHARACTER;
 }

 <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"\\"[0-7]{1,3} {
-	zendlval->value.lval = strtol(yytext+1, NULL, 8);
+	zendlval->value.chval = (char) strtol (yytext+1, NULL, 8);
 	return T_CHARACTER;
 }

 <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"\\x"[0-9A-Fa-f]{1,2} {
-	zendlval->value.lval = strtol (yytext+2, NULL, 16);
+	zendlval->value.chval = (char) strtol (yytext+2, NULL, 16);
 	return T_CHARACTER;
 }

-<ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"\\"{ANY_CHAR} {
+<ST_DOUBLE_QUOTES,ST_BACKQUOTE>"\\". {
 	switch (yytext[1]) {
 		case 'n':
-			zendlval->value.lval = (long) '\n';
+			zendlval->value.chval='\n';
 			break;
 		case 't':
-			zendlval->value.lval = (long) '\t';
+			zendlval->value.chval='\t';
 			break;
 		case 'r':
-			zendlval->value.lval = (long) '\r';
+			zendlval->value.chval='\r';
 			break;
 		case '\\':
-			zendlval->value.lval = (long) '\\';
+			zendlval->value.chval='\\';
 			break;
 		case '$':
-			zendlval->value.lval = (long) yytext[1];
+			zendlval->value.chval=yytext[1];
 			break;
 		case '{':
-			zendlval->value.lval = (long) yytext[1];
+			zendlval->value.chval=yytext[1];
 			break;
 		default:
 			zendlval->value.str.val = estrndup(yytext,yyleng);
@@ -1540,6 +1471,12 @@ ANY_CHAR (.|[\n])
 }


+<ST_HEREDOC>"\\$"|"\\{" {
+	zendlval->value.chval = yytext[1];
+	return T_CHARACTER;
+}
+
+
 <ST_HEREDOC>["'`]+ {
 	zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
 	zendlval->value.str.len = yyleng;
@@ -1570,13 +1507,7 @@ ANY_CHAR (.|[\n])
 	return 0;
 }

-<ST_COMMENT><<EOF>> {
-	zend_error(E_COMPILE_WARNING,"Unterminated comment starting line %d", CG(comment_start_line));
-	return 0;
-}
-	

-
-<ST_IN_SCRIPTING,INITIAL,ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_SINGLE_QUOTE,ST_HEREDOC>{ANY_CHAR} {
+<ST_IN_SCRIPTING,INITIAL,ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_SINGLE_QUOTE>. {
 	zend_error(E_COMPILE_WARNING,"Unexpected character in input:  '%c' (ASCII=%d) state=%d",yytext[0],yytext[0],YYSTATE);
 }
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -19,6 +19,8 @@


 #include "zend.h"
+#include "zend_operators.h"
+#include "zend_variables.h"
 #include "zend_extensions.h"
 #include "modules.h"
 #include "zend_constants.h"
@@ -36,28 +38,21 @@
 #	define GLOBAL_CONSTANTS_TABLE	CG(zend_constants)
 #endif

-#if defined(ZEND_WIN32) && ZEND_DEBUG
-BOOL WINAPI IsDebuggerPresent(VOID);
-#endif
-
 /* true multithread-shared globals */
 ZEND_API zend_class_entry zend_standard_class_def;
 ZEND_API int (*zend_printf)(const char *format, ...);
-ZEND_API zend_write_func_t zend_write;
-ZEND_API FILE *(*zend_fopen)(const char *filename, char **opened_path);
-ZEND_API void (*zend_block_interruptions)(void);
-ZEND_API void (*zend_unblock_interruptions)(void);
-ZEND_API void (*zend_ticks_function)(int ticks);
-ZEND_API void (*zend_error_cb)(int type, const char *error_filename, const uint error_lineno, const char *format, va_list args);
-
-static void (*zend_message_dispatcher_p)(long message, void *data);
-static int (*zend_get_ini_entry_p)(char *name, uint name_length, zval *contents);
-
+ZEND_API int (*zend_write)(const char *str, uint str_length);
+ZEND_API void (*zend_error)(int type, const char *format, ...);
+ZEND_API void (*zend_message_dispatcher)(long message, void *data);
+ZEND_API FILE *(*zend_fopen)(const char *filename);
+ZEND_API void (*zend_block_interruptions)();
+ZEND_API void (*zend_unblock_interruptions)();
+ZEND_API int (*zend_get_ini_entry)(char *name, uint name_length, zval *contents);

 #ifdef ZTS
 ZEND_API int compiler_globals_id;
 ZEND_API int executor_globals_id;
-ZEND_API int alloc_globals_id;
+int alloc_globals_id;
 HashTable *global_function_table;
 HashTable *global_class_table;
 HashTable *global_constants_table;
@@ -65,15 +60,13 @@ HashTable *global_constants_table;

 zend_utility_values zend_uv;

-ZEND_API zval zval_used_for_init; /* True global variable */
-
 /* version information */
 static char *zend_version_info;
 static uint zend_version_info_length;
-#define ZEND_CORE_VERSION_INFO	"Zend Engine v" ZEND_VERSION ", Copyright (c) 1998-2000 Zend Technologies\n"
+#define ZEND_CORE_VERSION_INFO	"Zend Engine v" ZEND_VERSION ", Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski\n"


-#define PRINT_ZVAL_INDENT 4
+#define PRINT_PVAL_INDENT 4

 static void print_hash(HashTable *ht, int indent)
 {
@@ -86,7 +79,7 @@ static void print_hash(HashTable *ht, int indent)
 		ZEND_PUTS(" ");
 	}
 	ZEND_PUTS("(\n");
-	indent += PRINT_ZVAL_INDENT;
+	indent += PRINT_PVAL_INDENT;
 	zend_hash_internal_pointer_reset(ht);
 	while (zend_hash_get_current_data(ht, (void **) &tmp) == SUCCESS) {
 		for (i=0; i<indent; i++) {
@@ -103,11 +96,11 @@ static void print_hash(HashTable *ht, int indent)
 				break;
 		}
 		ZEND_PUTS("] => ");
-		zend_print_zval_r(*tmp, indent+PRINT_ZVAL_INDENT);
+		zend_print_zval_r(*tmp, indent+PRINT_PVAL_INDENT);
 		ZEND_PUTS("\n");
 		zend_hash_move_forward(ht);
 	}
-	indent -= PRINT_ZVAL_INDENT;
+	indent -= PRINT_PVAL_INDENT;
 	for (i=0; i<indent; i++) {
 		ZEND_PUTS(" ");
 	}
@@ -122,11 +115,8 @@ ZEND_API void zend_make_printable_zval(zval *expr, zval *expr_copy, int *use_cop
 		return;
 	}
 	switch (expr->type) {
-		case IS_NULL:
-			expr_copy->value.str.len = 0;
-			expr_copy->value.str.val = empty_string;
-			break;
 		case IS_BOOL:
+#if 1
 			if (expr->value.lval) {
 				expr_copy->value.str.len = 1;
 				expr_copy->value.str.val = estrndup("1", 1);
@@ -134,6 +124,15 @@ ZEND_API void zend_make_printable_zval(zval *expr, zval *expr_copy, int *use_cop
 				expr_copy->value.str.len = 0;
 				expr_copy->value.str.val = empty_string;
 			}
+#else
+			if (expr->value.lval) {
+				expr_copy->value.str.len = sizeof("true")-1;
+				expr_copy->value.str.val = estrndup("true", expr_copy->value.str.len);
+			} else {
+				expr_copy->value.str.len = sizeof("false")-1;
+				expr_copy->value.str.val = estrndup("false", expr_copy->value.str.len);
+			}
+#endif
 			break;
 		case IS_RESOURCE:
 			expr_copy->value.str.val = (char *) emalloc(sizeof("Resource id #")-1 + MAX_LENGTH_OF_LONG);
@@ -143,9 +142,19 @@ ZEND_API void zend_make_printable_zval(zval *expr, zval *expr_copy, int *use_cop
 			expr_copy->value.str.len = sizeof("Array")-1;
 			expr_copy->value.str.val = estrndup("Array", expr_copy->value.str.len);
 			break;
-		case IS_OBJECT:
-			expr_copy->value.str.len = sizeof("Object")-1;
-			expr_copy->value.str.val = estrndup("Object", expr_copy->value.str.len);
+		case IS_OBJECT: {
+				zval function_name;
+
+				function_name.value.str.len = sizeof("to_string")-1;
+				function_name.value.str.val = estrndup("to_string", function_name.value.str.len);
+				function_name.type = IS_STRING;
+
+				if (call_user_function(NULL, expr, &function_name, expr_copy, 0, NULL)==FAILURE) {
+					expr_copy->value.str.len = sizeof("Object")-1;
+					expr_copy->value.str.val = estrndup("Object", expr_copy->value.str.len);
+				}
+				efree(function_name.value.str.val);
+			}
 			break;
 		default:
 			*expr_copy = *expr;
@@ -159,12 +168,6 @@ ZEND_API void zend_make_printable_zval(zval *expr, zval *expr_copy, int *use_cop


 ZEND_API int zend_print_zval(zval *expr, int indent)
-{
-	return zend_print_zval_ex(zend_write, expr, indent);
-}
-
-
-ZEND_API int zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int indent)
 {
 	zval expr_copy;
 	int use_copy;
@@ -179,7 +182,7 @@ ZEND_API int zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int in
 		}
 		return 0;
 	}
-	write_func(expr->value.str.val,expr->value.str.len);
+	ZEND_WRITE(expr->value.str.val,expr->value.str.len);
 	if (use_copy) {
 		zval_dtor(expr);
 	}
@@ -187,34 +190,16 @@ ZEND_API int zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int in
 }


-ZEND_API void zend_print_zval_r(zval *expr, int indent)
-{
-	zend_print_zval_r_ex(zend_write, expr, indent);
-}
-
-
-ZEND_API void zend_print_zval_r_ex(zend_write_func_t write_func, zval *expr, int indent) 
+ZEND_API void zend_print_zval_r(zval *expr, int indent) 
 {
 	switch(expr->type) {
 		case IS_ARRAY:
 			ZEND_PUTS("Array\n");
-			if (++expr->value.ht->nApplyCount>1) {
-				ZEND_PUTS(" *RECURSION*");
-				expr->value.ht->nApplyCount=0;
-				return;
-			}
 			print_hash(expr->value.ht,indent);
-			expr->value.ht->nApplyCount--;
 			break;
 		case IS_OBJECT:
-			if (++expr->value.obj.properties->nApplyCount>1) {
-				ZEND_PUTS(" *RECURSION*");
-				expr->value.obj.properties->nApplyCount=0;
-				return;
-			}
 			zend_printf("%s Object\n", expr->value.obj.ce->name);
 			print_hash(expr->value.obj.properties, indent);
-			expr->value.obj.properties->nApplyCount--;
 			break;
 		default:
 			zend_print_variable(expr);
@@ -223,23 +208,20 @@ ZEND_API void zend_print_zval_r_ex(zend_write_func_t write_func, zval *expr, int
 }


-static FILE *zend_fopen_wrapper(const char *filename, char **opened_path)
+static FILE *zend_fopen_wrapper(const char *filename)
 {
-	if (opened_path) {
-		*opened_path = estrdup(filename);
-	}
-	return fopen(filename, "rb");
+	return fopen(filename, "r");
 }


-static void register_standard_class(void)
+static void register_standard_class()
 {
 	zend_standard_class_def.type = ZEND_INTERNAL_CLASS;
 	zend_standard_class_def.name_length = sizeof("stdClass") - 1;
 	zend_standard_class_def.name = zend_strndup("stdClass", zend_standard_class_def.name_length);
 	zend_standard_class_def.parent = NULL;
-	zend_hash_init_ex(&zend_standard_class_def.default_properties, 0, NULL, ZVAL_PTR_DTOR, 1, 0);
-	zend_hash_init_ex(&zend_standard_class_def.function_table, 0, NULL, ZEND_FUNCTION_DTOR, 1, 0);
+	zend_hash_init(&zend_standard_class_def.default_properties, 0, NULL, PVAL_PTR_DTOR, 1);
+	zend_hash_init(&zend_standard_class_def.function_table, 0, NULL, ZEND_FUNCTION_DTOR, 1);
 	zend_standard_class_def.handle_function_call = NULL;
 	zend_standard_class_def.handle_property_get = NULL;
 	zend_standard_class_def.handle_property_set = NULL;
@@ -249,33 +231,19 @@ static void register_standard_class(void)
 }


-static void zend_set_default_compile_time_values(CLS_D)
-{
-	/* default compile-time values */
-	CG(asp_tags) = 0;
-	CG(short_tags) = 1;
-	CG(allow_call_time_pass_reference) = 1;
-	CG(extended_info) = 0;
-}
-
-
 #ifdef ZTS
 static void compiler_globals_ctor(zend_compiler_globals *compiler_globals)
 {
 	zend_function tmp_func;
 	zend_class_entry tmp_class;

-	compiler_globals->compiled_filename = NULL;
-
 	compiler_globals->function_table = (HashTable *) malloc(sizeof(HashTable));
-	zend_hash_init_ex(compiler_globals->function_table, 100, NULL, ZEND_FUNCTION_DTOR, 1, 0);
+	zend_hash_init(compiler_globals->function_table, 100, NULL, ZEND_FUNCTION_DTOR, 1);
 	zend_hash_copy(compiler_globals->function_table, global_function_table, NULL, &tmp_func, sizeof(zend_function));

 	compiler_globals->class_table = (HashTable *) malloc(sizeof(HashTable));
-	zend_hash_init_ex(compiler_globals->class_table, 10, NULL, ZEND_CLASS_DTOR, 1, 0);
-	zend_hash_copy(compiler_globals->class_table, global_class_table, (copy_ctor_func_t) zend_class_add_ref, &tmp_class, sizeof(zend_class_entry));
-
-	zend_set_default_compile_time_values(CLS_C);
+	zend_hash_init(compiler_globals->class_table, 10, NULL, ZEND_CLASS_DTOR, 1);
+	zend_hash_copy(compiler_globals->class_table, global_class_table, zend_class_add_ref, &tmp_class, sizeof(zend_class_entry));
 }


@@ -298,15 +266,14 @@ static void executor_globals_ctor(zend_executor_globals *executor_globals)
 		zend_startup_constants(ELS_C);
 		zend_copy_constants(executor_globals->zend_constants, global_constants_table);
 	}
-	zend_init_rsrc_plist(ELS_C);
-	EG(lambda_count)=0;
+	init_resource_plist(ELS_C);
 }


 static void executor_globals_dtor(zend_executor_globals *executor_globals)
 {
 	zend_shutdown_constants(ELS_C);
-	zend_destroy_rsrc_plist(ELS_C);
+	destroy_resource_plist();
 }


@@ -317,72 +284,47 @@ static void alloc_globals_ctor(zend_alloc_globals *alloc_globals)

 #endif

-#ifdef __FreeBSD__
-/* FreeBSD floating point precision fix */
-#include <floatingpoint.h>
-#endif

-int zend_startup(zend_utility_functions *utility_functions, char **extensions, int start_builtin_functions)
+int zend_startup(zend_utility_functions *utility_functions, char **extensions)
 {
 #ifdef ZTS
 	zend_compiler_globals *compiler_globals;
 	zend_executor_globals *executor_globals;

-	alloc_globals_id = ts_allocate_id(sizeof(zend_alloc_globals), (ts_allocate_ctor) alloc_globals_ctor, NULL);
+	alloc_globals_id = ts_allocate_id(sizeof(zend_alloc_globals), alloc_globals_ctor, NULL);
 #else
 	start_memory_manager(ALS_C);
 #endif

-#ifdef __FreeBSD__
-	{
-		/* FreeBSD floating point precision fix */
-#ifdef HAVE_FP_EXCEPT
-		fp_except
-#else
-		fp_except_t
-#endif
-		mask;
-
-		mask = fpgetmask();
-		fpsetmask(mask & ~FP_X_IMP);
-	} 
-#endif
-
-	zend_startup_extensions_mechanism();
-
 	/* Set up utility functions and values */
-	zend_error_cb = utility_functions->error_function;
+	zend_error = utility_functions->error_function;
 	zend_printf = utility_functions->printf_function;
-	zend_write = (zend_write_func_t) utility_functions->write_function;
+	zend_write = utility_functions->write_function;
 	zend_fopen = utility_functions->fopen_function;
 	if (!zend_fopen) {
 		zend_fopen = zend_fopen_wrapper;
 	}
-	zend_message_dispatcher_p = utility_functions->message_handler;
+	zend_message_dispatcher = utility_functions->message_handler;
 	zend_block_interruptions = utility_functions->block_interruptions;
 	zend_unblock_interruptions = utility_functions->unblock_interruptions;
-	zend_get_ini_entry_p = utility_functions->get_ini_entry;
-	zend_ticks_function = utility_functions->ticks_function;
+	zend_get_ini_entry = utility_functions->get_ini_entry;

-	zend_compile_file = compile_file;
+	zend_compile_files = compile_files;
 	zend_execute = execute;

+	zend_llist_init(&zend_extensions, sizeof(zend_extension), (void (*)(void *)) zend_extension_dtor, 1);
+
 	/* set up version */
 	zend_version_info = strdup(ZEND_CORE_VERSION_INFO);
 	zend_version_info_length = sizeof(ZEND_CORE_VERSION_INFO)-1;

 	GLOBAL_FUNCTION_TABLE = (HashTable *) malloc(sizeof(HashTable));
 	GLOBAL_CLASS_TABLE = (HashTable *) malloc(sizeof(HashTable));
-	zend_hash_init_ex(GLOBAL_FUNCTION_TABLE, 100, NULL, ZEND_FUNCTION_DTOR, 1, 0);
-	zend_hash_init_ex(GLOBAL_CLASS_TABLE, 10, NULL, ZEND_CLASS_DTOR, 1, 0);
+	zend_hash_init(GLOBAL_FUNCTION_TABLE, 100, NULL, ZEND_FUNCTION_DTOR, 1);
+	zend_hash_init(GLOBAL_CLASS_TABLE, 10, NULL, ZEND_CLASS_DTOR, 1);
 	register_standard_class();
-	zend_hash_init_ex(&module_registry, 50, NULL, ZEND_MODULE_DTOR, 1, 0);
-	zend_init_rsrc_list_dtors();
-
-	/* This zval can be used to initialize allocate zval's to an uninit'ed value */
-	zval_used_for_init.is_ref = 0;
-	zval_used_for_init.refcount = 1;
-	zval_used_for_init.type = IS_NULL;
+	zend_hash_init(&module_registry, 50, NULL, ZEND_MODULE_DTOR, 1);
+	zend_hash_init(&list_destructors, 50, NULL, NULL, 1);

 #ifdef ZTS
 	global_constants_table = NULL;
@@ -397,17 +339,14 @@ int zend_startup(zend_utility_functions *utility_functions, char **extensions, i
 	GLOBAL_CONSTANTS_TABLE = EG(zend_constants);
 #else
 	zend_startup_constants();
-	zend_set_default_compile_time_values(CLS_C);
 #endif
 	zend_register_standard_constants(ELS_C);

 #ifndef ZTS
-	zend_init_rsrc_plist(ELS_C);
+	init_resource_plist(ELS_C);
 #endif

-	if (start_builtin_functions) {
-		zend_startup_builtin_functions();
-	}
+	zend_startup_builtin_functions();

 	return SUCCESS;
 }
@@ -415,13 +354,10 @@ int zend_startup(zend_utility_functions *utility_functions, char **extensions, i

 void zend_shutdown()
 {
-#ifdef ZEND_WIN32
-	zend_shutdown_timeout_thread();
-#endif
 #ifndef ZTS
-	zend_destroy_rsrc_plist();
+	destroy_resource_plist();
 #endif
-	zend_destroy_rsrc_list_dtors();
+	zend_hash_destroy(&list_destructors);
 	zend_hash_destroy(&module_registry);
 	zend_hash_destroy(GLOBAL_FUNCTION_TABLE);
 	free(GLOBAL_FUNCTION_TABLE);
@@ -430,7 +366,7 @@ void zend_shutdown()
 	zend_shutdown_extensions();
 	free(zend_version_info);
 #ifndef ZTS
-	zend_shutdown_constants();
+	zend_shutdown_constants(ELS_C);
 #endif
 }

@@ -438,7 +374,6 @@ void zend_shutdown()
 void zend_set_utility_values(zend_utility_values *utility_values)
 {
 	zend_uv = *utility_values;
-	zend_uv.import_use_extension_length = strlen(zend_uv.import_use_extension);
 }


@@ -496,275 +431,10 @@ void zend_activate(CLS_D ELS_DC)
 	startup_scanner(CLS_C);
 }

-
-void zend_activate_modules()
-{
-	zend_hash_apply(&module_registry, (int (*)(void *)) module_registry_request_startup);
-}
-
-void zend_deactivate_modules()
-{
-	ELS_FETCH();
-	EG(opline_ptr) = NULL; /* we're no longer executing anything */
-
-	if (setjmp(EG(bailout))==0) {
-		zend_hash_apply(&module_registry, (int (*)(void *)) module_registry_cleanup);
-	}
-}
-
 void zend_deactivate(CLS_D ELS_DC)
 {
-	/* we're no longer executing anything */
-	EG(opline_ptr) = NULL; 
-	EG(active_symbol_table) = NULL;
-
-	if (setjmp(EG(bailout))==0) {
-		shutdown_scanner(CLS_C);
-	}
-	if (setjmp(EG(bailout))==0) {
-		shutdown_executor(ELS_C);
-	}
-	if (setjmp(EG(bailout))==0) {
-		shutdown_compiler(CLS_C);
-	}
+	zend_hash_apply(&module_registry, (int (*)(void *)) module_registry_cleanup);
+	shutdown_scanner(CLS_C);
+	shutdown_executor(ELS_C);
+	shutdown_compiler(CLS_C);
 }
-
-
-BEGIN_EXTERN_C()
-ZEND_API void zend_message_dispatcher(long message, void *data)
-{
-	if (zend_message_dispatcher_p) {
-		zend_message_dispatcher_p(message, data);
-	}
-}
-END_EXTERN_C()
-
-
-ZEND_API int zend_get_ini_entry(char *name, uint name_length, zval *contents)
-{
-	if (zend_get_ini_entry_p) {
-		return zend_get_ini_entry_p(name, name_length, contents);
-	} else {
-		return FAILURE;
-	}
-}
-
-
-#define ZEND_ERROR_BUFFER_SIZE 1024
-
-ZEND_API void zend_error(int type, const char *format, ...)
-{
-	va_list args;
-	zval ***params;
-	zval *retval;
-	zval *z_error_type, *z_error_message, *z_error_filename, *z_error_lineno, *z_context;
-	char *error_filename;
-	uint error_lineno;
-	zval *orig_user_error_handler;
-	ELS_FETCH();
-	CLS_FETCH();
-
-	/* Obtain relevant filename and lineno */
-	switch (type) {
-		case E_CORE_ERROR:
-		case E_CORE_WARNING:
-			error_filename = NULL;
-			error_lineno = 0;
-			break;
-		case E_PARSE:
-		case E_COMPILE_ERROR:
-		case E_COMPILE_WARNING:
-		case E_ERROR:
-		case E_NOTICE:
-		case E_WARNING:
-		case E_USER_ERROR:
-		case E_USER_WARNING:
-		case E_USER_NOTICE:
-			if (zend_is_compiling()) {
-				error_filename = zend_get_compiled_filename(CLS_C);
-				error_lineno = zend_get_compiled_lineno(CLS_C);
-			} else if (zend_is_executing()) {
-				error_filename = zend_get_executed_filename(ELS_C);
-				error_lineno = zend_get_executed_lineno(ELS_C);
-			} else {
-				error_filename = NULL;
-				error_lineno = 0;
-			}
-			break;
-		default:
-			error_filename = NULL;
-			error_lineno = 0;
-			break;
-	}
-	if (!error_filename) {
-		error_filename = "Unknown";
-	}
-
-
-	va_start(args, format);
-
-	/* if we don't have a user defined error handler */
-	if (!EG(user_error_handler)) {
-		zend_error_cb(type, error_filename, error_lineno, format, args);
-	} else switch (type) {
-		case E_ERROR:
-		case E_PARSE:
-		case E_CORE_ERROR:
-		case E_CORE_WARNING:
-		case E_COMPILE_ERROR:
-		case E_COMPILE_WARNING:
-			/* The error may not be safe to handle in user-space */
-			zend_error_cb(type, error_filename, error_lineno, format, args);
-			break;
-		default:
-			/* Handle the error in user space */
-			ALLOC_INIT_ZVAL(z_error_message);
-			ALLOC_INIT_ZVAL(z_error_type);
-			ALLOC_INIT_ZVAL(z_error_filename);
-			ALLOC_INIT_ZVAL(z_error_lineno);
-			ALLOC_INIT_ZVAL(z_context);
-			z_error_message->value.str.val = (char *) emalloc(ZEND_ERROR_BUFFER_SIZE);
-
-#ifdef HAVE_VSNPRINTF
-			z_error_message->value.str.len = vsnprintf(z_error_message->value.str.val, ZEND_ERROR_BUFFER_SIZE, format, args);
-			if (z_error_message->value.str.len > ZEND_ERROR_BUFFER_SIZE-1) {
-				z_error_message->value.str.len = ZEND_ERROR_BUFFER_SIZE-1;
-			}
-#else
-			strncpy(z_error_message->value.str.val, format, ZEND_ERROR_BUFFER_SIZE);
-			/* This is risky... */
-			/* z_error_message->value.str.len = vsprintf(z_error_message->value.str.val, format, args); */
-#endif
-			z_error_message->type = IS_STRING;
-
-			z_error_type->value.lval = type;
-			z_error_type->type = IS_LONG;
-
-			if (error_filename) {
-				z_error_filename->value.str.len = strlen(error_filename);
-				z_error_filename->value.str.val = estrndup(error_filename, z_error_filename->value.str.len);
-				z_error_filename->type = IS_STRING;
-			}
-				
-			z_error_lineno->value.lval = error_lineno;
-			z_error_lineno->type = IS_LONG;
-
-			z_context->value.ht = EG(active_symbol_table);
-			z_context->type = IS_ARRAY;
-			ZVAL_ADDREF(z_context);  /* we don't want this one to be freed */
-
-			params = (zval ***) emalloc(sizeof(zval **)*5);
-			params[0] = &z_error_type;
-			params[1] = &z_error_message;
-			params[2] = &z_error_filename;
-			params[3] = &z_error_lineno;
-			params[4] = &z_context;
-
-			orig_user_error_handler = EG(user_error_handler);
-			EG(user_error_handler) = NULL;
-			if (call_user_function_ex(CG(function_table), NULL, orig_user_error_handler, &retval, 5, params, 1, NULL)==SUCCESS) {
-				zval_ptr_dtor(&retval);
-			} else {
-				/* The user error handler failed, use built-in error handler */
-				zend_error_cb(type, error_filename, error_lineno, format, args);
-			}
-			EG(user_error_handler) = orig_user_error_handler;
-
-			efree(params);
-			zval_ptr_dtor(&z_error_message);
-			zval_ptr_dtor(&z_error_type);
-			zval_ptr_dtor(&z_error_filename);
-			zval_ptr_dtor(&z_error_lineno);
-			if (ZVAL_REFCOUNT(z_context)==2) {
-				FREE_ZVAL(z_context);
-			}
-			break;
-	}
-
-	va_end(args);
-}
-
-
-ZEND_API void zend_output_debug_string(zend_bool trigger_break, char *format, ...)
-{
-#if ZEND_DEBUG
-	va_list args;
-
-	va_start(args, format);
-#	ifdef ZEND_WIN32
-	{
-		char output_buf[1024];
-
-		vsnprintf(output_buf, 1024, format, args);
-		OutputDebugString(output_buf);
-		OutputDebugString("\n");
-		if (trigger_break && IsDebuggerPresent()) {
-			DebugBreak();
-		}
-	}
-#	else
-	vfprintf(stderr, format, args);
-	fprintf(stderr, "\n");
-#	endif
-	va_end(args);
-#endif
-}
-
-
-ZEND_API int zend_execute_scripts(int type CLS_DC ELS_DC, int file_count, ...)
-{
-	va_list files;
-	int i;
-	zend_file_handle *file_handle;
-
-	va_start(files, file_count);
-	for (i=0; i<file_count; i++) {
-		file_handle = va_arg(files, zend_file_handle *);
-		if (!file_handle) {
-			continue;
-		}
-		EG(active_op_array) = zend_compile_file(file_handle, ZEND_INCLUDE CLS_CC);
-		zend_destroy_file_handle(file_handle CLS_CC);
-		if (EG(active_op_array)) {
-			zend_execute(EG(active_op_array) ELS_CC);
-			zval_ptr_dtor(EG(return_value_ptr_ptr));
-			EG(return_value_ptr_ptr) = &EG(global_return_value_ptr);
-			EG(global_return_value_ptr) = NULL;
-			destroy_op_array(EG(active_op_array));
-			efree(EG(active_op_array));
-		} else if (type==ZEND_REQUIRE) {
-			va_end(files);
-			return FAILURE;
-		}
-	}
-	va_end(files);
-
-	return SUCCESS;
-}
-
-#define COMPILED_STRING_DESCRIPTION_FORMAT "%s(%d) : %s"
-
-ZEND_API char *zend_make_compiled_string_description(char *name)
-{
-	char *cur_filename;
-	int cur_lineno;
-	char *compiled_string_description;
-	CLS_FETCH();
-	ELS_FETCH();
-
-	if (zend_is_compiling()) {
-		cur_filename = zend_get_compiled_filename(CLS_C);
-		cur_lineno = zend_get_compiled_lineno(CLS_C);
-	} else if (zend_is_executing()) {
-		cur_filename = zend_get_executed_filename(ELS_C);
-		cur_lineno = zend_get_executed_lineno(ELS_C);
-	} else {
-		cur_filename = "Unknown";
-		cur_lineno = 0;
-	}
-
-	compiled_string_description = emalloc(sizeof(COMPILED_STRING_DESCRIPTION_FORMAT)+strlen(name)+strlen(cur_filename)+MAX_LENGTH_OF_LONG);
-	sprintf(compiled_string_description, COMPILED_STRING_DESCRIPTION_FORMAT, cur_filename, cur_lineno, name);
-	return compiled_string_description;
-}
-
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -18,10 +18,10 @@
 */


-#ifndef ZEND_H
-#define ZEND_H
+#ifndef _ZEND_H
+#define _ZEND_H

-#define ZEND_VERSION "1.0.3"
+#define ZEND_VERSION "0.90"

 #ifdef __cplusplus
 #define BEGIN_EXTERN_C() extern "C" {
@@ -37,7 +37,7 @@
 * general definitions
 */

-#ifdef ZEND_WIN32
+#if (defined(WINNT) && WINNT) || (defined(WIN32) && WIN32)
 # include "zend_config.w32.h"
 #else
 # include "zend_config.h"
@@ -53,48 +53,6 @@
 # include <stdarg.h>
 #endif

-#ifdef HAVE_DLFCN_H
-# include <dlfcn.h>
-#endif
-
-#if defined(HAVE_LIBDL)
-
-# ifndef RTLD_LAZY
-#  define RTLD_LAZY 1    /* Solaris 1, FreeBSD's (2.1.7.1 and older) */
-# endif
-
-# ifndef RTLD_GLOBAL
-#  define RTLD_GLOBAL 0
-# endif
-
-# define DL_LOAD(libname)			dlopen(libname, RTLD_LAZY | RTLD_GLOBAL)
-# define DL_UNLOAD					dlclose
-# define DL_FETCH_SYMBOL			dlsym
-# define DL_HANDLE					void *
-# define ZEND_EXTENSIONS_SUPPORT	1
-#elif defined(ZEND_WIN32)
-# define DL_LOAD(libname)			LoadLibrary(libname)
-# define DL_FETCH_SYMBOL			GetProcAddress
-# define DL_UNLOAD					FreeLibrary
-# define DL_HANDLE					HMODULE
-# define ZEND_EXTENSIONS_SUPPORT	1
-#else
-# define DL_HANDLE					void *
-# define ZEND_EXTENSIONS_SUPPORT	0
-#endif
-
-#if HAVE_ALLOCA_H
-# include <alloca.h>
-#endif
-
-#if (HAVE_ALLOCA || (defined (__GNUC__) && __GNUC__ >= 2)) && !(defined(ZTS) && defined(ZEND_WIN32))
-# define do_alloca(p) alloca(p)
-# define free_alloca(p)
-#else
-# define do_alloca(p)		emalloc(p)
-# define free_alloca(p)	efree(p)
-#endif
-
 #if ZEND_DEBUG
 #define ZEND_FILE_LINE_D				char *__zend_filename, uint __zend_lineno
 #define ZEND_FILE_LINE_DC				, ZEND_FILE_LINE_D
@@ -123,20 +81,11 @@
 #define ZEND_FILE_LINE_ORIG_RELAY_CC
 #endif	/* ZEND_DEBUG */

-#ifdef ZTS
-#define ZTS_V 1
-#else
-#define ZTS_V 0
-#endif

 #include "zend_errors.h"
 #include "zend_alloc.h"

 typedef unsigned char zend_bool;
-typedef unsigned char zend_uchar;
-typedef unsigned int zend_uint;
-typedef unsigned long zend_ulong;
-typedef unsigned short zend_ushort;

 #undef SUCCESS
 #undef FAILURE
@@ -147,8 +96,8 @@ typedef unsigned short zend_ushort;
 #include "zend_hash.h"
 #include "zend_llist.h"

-#define INTERNAL_FUNCTION_PARAMETERS int ht, zval *return_value, zval *this_ptr, int return_value_used ELS_DC
-#define INTERNAL_FUNCTION_PARAM_PASSTHRU ht, return_value, this_ptr, return_value_used ELS_CC
+#define INTERNAL_FUNCTION_PARAMETERS int ht, zval *return_value, HashTable *list, HashTable *plist, zval *this_ptr
+#define INTERNAL_FUNCTION_PARAM_PASSTHRU ht, return_value, list, plist, this_ptr

 /*
 * zval
@@ -163,6 +112,7 @@ typedef union _zvalue_value {
 		char *val;
 		int len;
 	} str;
+	char chval;					/* char value */
 	HashTable *ht;				/* hash table value */
 	struct {
 		zend_class_entry *ce;
@@ -174,9 +124,9 @@ typedef union _zvalue_value {
 struct _zval_struct {
 	/* Variable information */
 	zvalue_value value;		/* value */
-	zend_uchar type;	/* active type */
-	zend_uchar is_ref;
-	zend_ushort refcount;
+	unsigned char type;	/* active type */
+	unsigned char is_ref;
+	short refcount;
 };


@@ -191,7 +141,7 @@ typedef struct _zend_function_entry {
 typedef struct _zend_property_reference {
 	int type;  /* read, write or r/w */
 	zval *object;
-	zend_llist *elements_list;
+	zend_llist elements_list;
 } zend_property_reference;


@@ -210,7 +160,6 @@ struct _zend_class_entry {
 	uint name_length;
 	struct _zend_class_entry *parent; 
 	int *refcount;
-	zend_bool constants_updated;

 	HashTable function_table;
 	HashTable default_properties;
@@ -225,124 +174,80 @@ struct _zend_class_entry {


 typedef struct _zend_utility_functions {
-	void (*error_function)(int type, const char *error_filename, const uint error_lineno, const char *format, va_list args);
+	void (*error_function)(int type, const char *format, ...);
 	int (*printf_function)(const char *format, ...);
 	int (*write_function)(const char *str, uint str_length);
-	FILE *(*fopen_function)(const char *filename, char **opened_path);
+	FILE *(*fopen_function)(const char *filename);
 	void (*message_handler)(long message, void *data);
-	void (*block_interruptions)(void);
-	void (*unblock_interruptions)(void);
+	void (*block_interruptions)();
+	void (*unblock_interruptions)();
 	int (*get_ini_entry)(char *name, uint name_length, zval *contents);
-	void (*ticks_function)(int ticks);
 } zend_utility_functions;

 		
 typedef struct _zend_utility_values {
-	char *import_use_extension;
-	uint import_use_extension_length;
+	unsigned char short_tags;
+	unsigned char asp_tags;
 } zend_utility_values;


-typedef int (*zend_write_func_t)(const char *str, uint str_length);
-
-
 #undef MIN
 #undef MAX
 #define MAX(a,b)  (((a)>(b))?(a):(b))
 #define MIN(a,b)  (((a)<(b))?(a):(b))
-#define ZEND_STRL(str)		(str), (sizeof(str)-1)
-#define ZEND_STRS(str)		(str), (sizeof(str)
-#define ZEND_NORMALIZE_BOOL(n)			\
-	((n) ? (((n)>0) ? 1 : -1) : 0)
-

 /* data types */
-#define IS_NULL		0
 #define IS_LONG		1
 #define IS_DOUBLE	2
 #define IS_STRING	3
 #define IS_ARRAY	4
 #define IS_OBJECT	5
-#define IS_BOOL		6
-#define IS_RESOURCE	7
-#define IS_CONSTANT	8
-#define IS_CONSTANT_ARRAY	9
+#define IS_BC 		6 /* for parser internal use only */
+#define IS_BOOL		7
+#define IS_RESOURCE 8
+#define IS_CONSTANT	9
+#define IS_METHOD	10 /* for overloaded function calls */

-/* Special data type to temporarily mark large numbers */
-#define FLAG_IS_BC	10 /* for parser internal use only */
-
-/* overloaded elements data types */
-#define OE_IS_ARRAY	(1<<0)
-#define OE_IS_OBJECT	(1<<1)
-#define OE_IS_METHOD	(1<<2)
-
-
-/* Argument passing types */
-#define BYREF_NONE 0
-#define BYREF_FORCE 1
-#define BYREF_ALLOW 2
-#define BYREF_FORCE_REST 3
-
-int zend_startup(zend_utility_functions *utility_functions, char **extensions, int start_builtin_functions);
-void zend_shutdown(void);
+int zend_startup(zend_utility_functions *utility_functions, char **extensions);
+void zend_shutdown();

 void zend_set_utility_values(zend_utility_values *utility_values);
 BEGIN_EXTERN_C()
-ZEND_API void zend_bailout(void);
+ZEND_API void zend_bailout();
 END_EXTERN_C()
-ZEND_API char *get_zend_version(void);
+ZEND_API char *get_zend_version();

 ZEND_API void zend_make_printable_zval(zval *expr, zval *expr_copy, int *use_copy);
 ZEND_API int zend_print_zval(zval *expr, int indent);
-ZEND_API int zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int indent);
 ZEND_API void zend_print_zval_r(zval *expr, int indent);
-ZEND_API void zend_print_zval_r_ex(zend_write_func_t write_func, zval *expr, int indent);
-
-ZEND_API void zend_output_debug_string(zend_bool trigger_break, char *format, ...);
-#if ZEND_DEBUG
-#define Z_DBG(expr)		(expr)
-#else
-#define	Z_DBG(expr)
-#endif

 ZEND_API extern char *empty_string;
+ZEND_API extern char *undefined_variable_string;

-#define STR_FREE(ptr) if (ptr && ptr!=empty_string) { efree(ptr); }
-#define STR_FREE_REL(ptr) if (ptr && ptr!=empty_string) { efree_rel(ptr); }
-
-#define STR_REALLOC(ptr, size)										\
-	if (ptr!=empty_string) {										\
-		ptr = (char *) erealloc(ptr, size);							\
-	} else {														\
-		ptr = (char *) emalloc(size);								\
-		memset(ptr, 0, size);										\
-	}
+#define STR_FREE(ptr) if (ptr && ptr!=empty_string && ptr!=undefined_variable_string) { efree(ptr); }
+#define STR_FREE_REL(ptr) if (ptr && ptr!=empty_string && ptr!=undefined_variable_string) { efree_rel(ptr); }

 /* output support */
 #define ZEND_WRITE(str, str_len)		zend_write((str), (str_len))
 #define ZEND_PUTS(str)					zend_write((str), strlen((str)))
 #define ZEND_PUTC(c)					zend_write(&(c), 1), (c)

-
 BEGIN_EXTERN_C()
 extern ZEND_API int (*zend_printf)(const char *format, ...);
-extern ZEND_API zend_write_func_t zend_write;
-extern ZEND_API FILE *(*zend_fopen)(const char *filename, char **opened_path);
-extern ZEND_API void (*zend_block_interruptions)(void);
-extern ZEND_API void (*zend_unblock_interruptions)(void);
-extern ZEND_API void (*zend_ticks_function)(int ticks);
-extern ZEND_API void (*zend_error_cb)(int type, const char *error_filename, const uint error_lineno, const char *format, va_list args);
+extern ZEND_API int (*zend_write)(const char *str, uint str_length);
+extern ZEND_API void (*zend_error)(int type, const char *format, ...);
+extern ZEND_API FILE *(*zend_fopen)(const char *filename);
+extern ZEND_API void (*zend_block_interruptions)();
+extern ZEND_API void (*zend_unblock_interruptions)();
+extern ZEND_API void (*zend_message_dispatcher)(long message, void *data);
+extern ZEND_API int (*zend_get_ini_entry)(char *name, uint name_length, zval *contents);
+END_EXTERN_C()


-ZEND_API void zend_error(int type, const char *format, ...);
-
 void zenderror(char *error);

 extern ZEND_API zend_class_entry zend_standard_class_def;
 extern zend_utility_values zend_uv;
-extern ZEND_API zval zval_used_for_init;
-
-END_EXTERN_C()

 #define ZEND_UV(name) (zend_uv.name)

@@ -350,106 +255,41 @@ END_EXTERN_C()
 #define HANDLE_BLOCK_INTERRUPTIONS()		if (zend_block_interruptions) { zend_block_interruptions(); }
 #define HANDLE_UNBLOCK_INTERRUPTIONS()		if (zend_unblock_interruptions) { zend_unblock_interruptions(); }

-BEGIN_EXTERN_C()
-ZEND_API void zend_message_dispatcher(long message, void *data);
-END_EXTERN_C()
-
-ZEND_API int zend_get_ini_entry(char *name, uint name_length, zval *contents);
-

 /* Messages for applications of Zend */
-#define ZMSG_FAILED_INCLUDE_FOPEN		1L
-#define ZMSG_FAILED_REQUIRE_FOPEN		2L
-#define ZMSG_FAILED_HIGHLIGHT_FOPEN		3L
-#define ZMSG_MEMORY_LEAK_DETECTED		4L
-#define ZMSG_MEMORY_LEAK_REPEATED		5L
-#define ZMSG_LOG_SCRIPT_NAME			6L
-
-
-#define ZVAL_ADDREF(pz)		(++(pz)->refcount)
-#define ZVAL_DELREF(pz)		(--(pz)->refcount)
-#define ZVAL_REFCOUNT(pz)	((pz)->refcount)
+#define ZMSG_ENABLE_TRACK_VARS			1L
+#define ZMSG_FAILED_INCLUDE_FOPEN		2L
+#define ZMSG_FAILED_REQUIRE_FOPEN		3L
+#define ZMSG_FAILED_HIGHLIGHT_FOPEN		4L
+#define ZMSG_MEMORY_LEAK_DETECTED		5L
+#define ZMSG_MEMORY_LEAK_REPEATED		6L
+#define ZMSG_LOG_SCRIPT_NAME		7L

 #define INIT_PZVAL(z)		\
 	(z)->refcount = 1;		\
 	(z)->is_ref = 0;	

-#define INIT_ZVAL(z) z = zval_used_for_init;
-
-#define ALLOC_INIT_ZVAL(zp)						\
-	ALLOC_ZVAL(zp);		\
-	INIT_ZVAL(*zp);
-
 #define MAKE_STD_ZVAL(zv)				 \
-	ALLOC_ZVAL(zv); \
+	zv = (zval *) emalloc(sizeof(zval)); \
 	INIT_PZVAL(zv);

-#define PZVAL_IS_REF(z)		((z)->is_ref)
-
 #define SEPARATE_ZVAL(ppzv)									\
 	{														\
 		zval *orig_ptr = *(ppzv);							\
 															\
 		if (orig_ptr->refcount>1) {							\
 			orig_ptr->refcount--;							\
-			ALLOC_ZVAL(*(ppzv));							\
+			*(ppzv) = (zval *) emalloc(sizeof(zval));		\
 			**(ppzv) = *orig_ptr;							\
 			zval_copy_ctor(*(ppzv));						\
 			(*(ppzv))->refcount=1;							\
-			(*(ppzv))->is_ref = 0;							\
+			(*(ppzv))->is_ref = 0;						\
 		}													\
 	}

-#define SEPARATE_ZVAL_IF_NOT_REF(ppzv)		\
-	if (!PZVAL_IS_REF(*ppzv)) {				\
-		SEPARATE_ZVAL(ppzv);				\
-	}
+#define ZEND_MAX_RESERVED_RESOURCES	1

-#define SEPARATE_ZVAL_TO_MAKE_IS_REF(ppzv)	\
-	if (!PZVAL_IS_REF(*ppzv)) {				\
-		SEPARATE_ZVAL(ppzv);				\
-		(*(ppzv))->is_ref = 1;				\
-	}
-
-#define COPY_PZVAL_TO_ZVAL(zv, pzv)			\
-	(zv) = *(pzv);							\
-	if ((pzv)->refcount>1) {				\
-		zval_copy_ctor(&(zv));				\
-		(pzv)->refcount--;					\
-	} else {								\
-		FREE_ZVAL(pzv);						\
-	}										\
-	INIT_PZVAL(&(zv));
-
-#define REPLACE_ZVAL_VALUE(ppzv_dest,pzv_src,copy) {	\
-	int is_ref,refcount;						\
-												\
-	SEPARATE_ZVAL_IF_NOT_REF(ppzv_dest);		\
-	is_ref = (*ppzv_dest)->is_ref;				\
-	refcount = (*ppzv_dest)->refcount;			\
-	zval_dtor(*ppzv_dest);						\
-	**ppzv_dest = *pzv_src;						\
-	if(copy) {                                  \
-		zval_copy_ctor(*ppzv_dest);				\
-    }		                                    \
-	(*ppzv_dest)->is_ref = is_ref;				\
-	(*ppzv_dest)->refcount = refcount;			\
-}
-
-#define ZEND_MAX_RESERVED_RESOURCES	2
-
-#ifdef ZEND_WIN32
-/* Only use this macro if you know for sure that all of the switches values
-   are covered by its case statements */
-#define EMPTY_SWITCH_DEFAULT_CASE() \
-			default:				\
-				__assume(0);		\
-				break;
-#else
-#define EMPTY_SWITCH_DEFAULT_CASE()
-#endif
-
-#endif /* ZEND_H */
+#endif /* _ZEND_H */

 /*
 * Local variables:
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -19,29 +19,32 @@


 #include "zend.h"
+#include "zend_variables.h"
 #include "zend_execute.h"
 #include "zend_API.h"
 #include "modules.h"
 #include "zend_constants.h"
+#include "zend_operators.h"

 #ifdef HAVE_STDARG_H
-#include <stdarg.h>
+# include <stdarg.h>
 #endif

 /* these variables are true statics/globals, and have to be mutex'ed on every access */
 static int module_count=0;
-ZEND_API HashTable module_registry;
+HashTable list_destructors, module_registry;

 /* this function doesn't check for too many parameters */
-ZEND_API int zend_get_parameters(int ht, int param_count, ...)
+ZEND_API int getParameters(int ht, int param_count,...)
 {
 	void **p;
 	int arg_count;
 	va_list ptr;
 	zval **param, *param_ptr;
 	ELS_FETCH();
+	ALS_FETCH();

-	p = EG(argument_stack).top_element-2;
+	p = EG(argument_stack).top_element-1;
 	arg_count = (ulong) *p;

 	if (param_count>arg_count) {
@@ -50,22 +53,22 @@ ZEND_API int zend_get_parameters(int ht, int param_count, ...)

 	va_start(ptr, param_count);

-	while (param_count-->0) {
+	while (param_count>0) {
 		param = va_arg(ptr, zval **);
-		param_ptr = *(p-arg_count);
+		param_ptr = *(p-param_count);
 		if (!PZVAL_IS_REF(param_ptr) && param_ptr->refcount>1) {
 			zval *new_tmp;

-			ALLOC_ZVAL(new_tmp);
+			new_tmp = (zval *) emalloc(sizeof(zval));
 			*new_tmp = *param_ptr;
 			zval_copy_ctor(new_tmp);
 			INIT_PZVAL(new_tmp);
 			param_ptr = new_tmp;
-			((zval *) *(p-arg_count))->refcount--;
-			*(p-arg_count) = param_ptr;
+			((zval *) *(p-param_count))->refcount--;
+			*(p-param_count) = param_ptr;
 		}
 		*param = param_ptr;
-		arg_count--;
+		param_count--;
 	}
 	va_end(ptr);

@@ -73,35 +76,36 @@ ZEND_API int zend_get_parameters(int ht, int param_count, ...)
 }


-ZEND_API int zend_get_parameters_array(int ht, int param_count, zval **argument_array)
+ZEND_API int getParametersArray(int ht, int param_count, zval **argument_array)
 {
 	void **p;
 	int arg_count;
 	zval *param_ptr;
 	ELS_FETCH();

-	p = EG(argument_stack).top_element-2;
+	p = EG(argument_stack).top_element-1;
 	arg_count = (ulong) *p;

 	if (param_count>arg_count) {
 		return FAILURE;
 	}

-	while (param_count-->0) {
-		param_ptr = *(p-arg_count);
+
+	while (param_count>0) {
+		param_ptr = *(p-param_count);
 		if (!PZVAL_IS_REF(param_ptr) && param_ptr->refcount>1) {
 			zval *new_tmp;

-			ALLOC_ZVAL(new_tmp);
+			new_tmp = (zval *) emalloc(sizeof(zval));
 			*new_tmp = *param_ptr;
 			zval_copy_ctor(new_tmp);
 			INIT_PZVAL(new_tmp);
 			param_ptr = new_tmp;
-			((zval *) *(p-arg_count))->refcount--;
-			*(p-arg_count) = param_ptr;
+			((zval *) *(p-param_count))->refcount--;
+			*(p-param_count) = param_ptr;
 		}
 		*(argument_array++) = param_ptr;
-		arg_count--;
+		param_count--;
 	}

 	return SUCCESS;
@@ -112,7 +116,7 @@ ZEND_API int zend_get_parameters_array(int ht, int param_count, zval **argument_

 /* Zend-optimized Extended functions */
 /* this function doesn't check for too many parameters */
-ZEND_API int zend_get_parameters_ex(int param_count, ...)
+ZEND_API int getParametersEx(int param_count,...)
 {
 	void **p;
 	int arg_count;
@@ -120,7 +124,7 @@ ZEND_API int zend_get_parameters_ex(int param_count, ...)
 	zval ***param;
 	ELS_FETCH();

-	p = EG(argument_stack).top_element-2;
+	p = EG(argument_stack).top_element-1;
 	arg_count = (ulong) *p;

 	if (param_count>arg_count) {
@@ -128,9 +132,9 @@ ZEND_API int zend_get_parameters_ex(int param_count, ...)
 	}

 	va_start(ptr, param_count);
-	while (param_count-->0) {
+	while (param_count>0) {
 		param = va_arg(ptr, zval ***);
-		*param = (zval **) p-(arg_count--);
+		*param = (zval **) p-(param_count--);
 	}
 	va_end(ptr);

@@ -138,21 +142,21 @@ ZEND_API int zend_get_parameters_ex(int param_count, ...)
 }


-ZEND_API int zend_get_parameters_array_ex(int param_count, zval ***argument_array)
+ZEND_API int getParametersArrayEx(int param_count, zval ***argument_array)
 {
 	void **p;
 	int arg_count;
 	ELS_FETCH();

-	p = EG(argument_stack).top_element-2;
+	p = EG(argument_stack).top_element-1;
 	arg_count = (ulong) *p;

 	if (param_count>arg_count) {
 		return FAILURE;
 	}

-	while (param_count-->0) {
-		*(argument_array++) = (zval **) p-(arg_count--);
+	while (param_count>0) {
+		*(argument_array++) = (zval **) p-(param_count--);
 	}

 	return SUCCESS;
@@ -166,7 +170,7 @@ ZEND_API int ParameterPassedByReference(int ht, uint n)
 	zval *arg;
 	ELS_FETCH();

-	p = EG(argument_stack).elements+EG(argument_stack).top-2;
+	p = EG(argument_stack).elements+EG(argument_stack).top-1;
 	arg_count = (ulong) *p;

 	if (n>arg_count) {
@@ -183,12 +187,11 @@ ZEND_API void wrong_param_count()
 }

 	
-ZEND_API inline int _array_init(zval *arg ZEND_FILE_LINE_DC)
+ZEND_API inline int array_init(zval *arg)
 {
-	ALLOC_HASHTABLE_REL(arg->value.ht);
-
-	if (!arg->value.ht || zend_hash_init(arg->value.ht, 0, NULL, ZVAL_PTR_DTOR, 0)) {
-		zend_error(E_ERROR, "Cannot allocate memory for array");
+	arg->value.ht = (HashTable *) emalloc(sizeof(HashTable));
+	if (!arg->value.ht || zend_hash_init(arg->value.ht, 0, NULL, PVAL_PTR_DTOR, 0)) {
+		zend_error(E_CORE_ERROR, "Cannot allocate memory for array");
 		return FAILURE;
 	}
 	arg->type = IS_ARRAY;
@@ -196,27 +199,30 @@ ZEND_API inline int _array_init(zval *arg ZEND_FILE_LINE_DC)
 }


-ZEND_API inline int _object_init_ex(zval *arg, zend_class_entry *class_type ZEND_FILE_LINE_DC)
+static void zval_update_const_and_ref(zval **p)
+{
+	zval_update_constant(*p);
+	zval_add_ref(p);
+}
+
+
+
+ZEND_API inline int object_init_ex(zval *arg, zend_class_entry *class_type)
 {
 	zval *tmp;

-	if (!class_type->constants_updated) {
-		zend_hash_apply_with_argument(&class_type->default_properties, (int (*)(void *,void *)) zval_update_constant, (void *) 1);
-		class_type->constants_updated = 1;
-	}
-	
-	ALLOC_HASHTABLE_REL(arg->value.obj.properties);
-	zend_hash_init(arg->value.obj.properties, 0, NULL, ZVAL_PTR_DTOR, 0);
-	zend_hash_copy(arg->value.obj.properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
+	arg->value.obj.properties = (HashTable *) emalloc(sizeof(HashTable));
+	zend_hash_init(arg->value.obj.properties, 0, NULL, PVAL_PTR_DTOR, 0);
+	zend_hash_copy(arg->value.obj.properties, &class_type->default_properties, (void (*)(void *)) zval_update_const_and_ref, (void *) &tmp, sizeof(zval *));
 	arg->type = IS_OBJECT;
 	arg->value.obj.ce = class_type;
 	return SUCCESS;
 }


-ZEND_API inline int _object_init(zval *arg ZEND_FILE_LINE_DC)
+ZEND_API inline int object_init(zval *arg)
 {
-	return _object_init_ex(arg, &zend_standard_class_def ZEND_FILE_LINE_CC);
+	return object_init_ex(arg, &zend_standard_class_def);
 }


@@ -229,9 +235,8 @@ ZEND_API inline int add_assoc_function(zval *arg, char *key,void (*function_ptr)

 ZEND_API inline int add_assoc_long(zval *arg, char *key, long n)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_LONG;
 	tmp->value.lval = n;
 	INIT_PZVAL(tmp);
@@ -239,21 +244,10 @@ ZEND_API inline int add_assoc_long(zval *arg, char *key, long n)
 }


-ZEND_API inline int add_assoc_unset(zval *arg, char *key)
-{
-	zval *tmp;
-
-	ALLOC_ZVAL(tmp);
-	tmp->type = IS_NULL;
-	INIT_PZVAL(tmp);
-	return zend_hash_update(arg->value.ht, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
-}
-
 ZEND_API inline int add_assoc_bool(zval *arg, char *key, int b)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_BOOL;
 	tmp->value.lval = b;
 	INIT_PZVAL(tmp);
@@ -263,9 +257,8 @@ ZEND_API inline int add_assoc_bool(zval *arg, char *key, int b)

 ZEND_API inline int add_assoc_resource(zval *arg, char *key, int r)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_RESOURCE;
 	tmp->value.lval = r;
 	INIT_PZVAL(tmp);
@@ -275,9 +268,8 @@ ZEND_API inline int add_assoc_resource(zval *arg, char *key, int r)

 ZEND_API inline int add_assoc_double(zval *arg, char *key, double d)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_DOUBLE;
 	tmp->value.dval = d;
 	INIT_PZVAL(tmp);
@@ -287,9 +279,8 @@ ZEND_API inline int add_assoc_double(zval *arg, char *key, double d)

 ZEND_API inline int add_assoc_string(zval *arg, char *key, char *str, int duplicate)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_STRING;
 	tmp->value.str.len = strlen(str);
 	if (duplicate) {
@@ -304,9 +295,8 @@ ZEND_API inline int add_assoc_string(zval *arg, char *key, char *str, int duplic

 ZEND_API inline int add_assoc_stringl(zval *arg, char *key, char *str, uint length, int duplicate)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_STRING;
 	tmp->value.str.len = length;
 	if (duplicate) {
@@ -321,9 +311,8 @@ ZEND_API inline int add_assoc_stringl(zval *arg, char *key, char *str, uint leng

 ZEND_API inline int add_index_long(zval *arg, uint index, long n)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_LONG;
 	tmp->value.lval = n;
 	INIT_PZVAL(tmp);
@@ -331,22 +320,10 @@ ZEND_API inline int add_index_long(zval *arg, uint index, long n)
 }


-ZEND_API inline int add_index_unset(zval *arg, uint index)
-{
-	zval *tmp;
-
-	ALLOC_ZVAL(tmp);
-	tmp->type = IS_NULL;
-	INIT_PZVAL(tmp);
-	return zend_hash_index_update(arg->value.ht, index, (void *) &tmp, sizeof(zval *), NULL);
-}
-
-
 ZEND_API inline int add_index_bool(zval *arg, uint index, int b)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_BOOL;
 	tmp->value.lval = b;
 	INIT_PZVAL(tmp);
@@ -356,9 +333,8 @@ ZEND_API inline int add_index_bool(zval *arg, uint index, int b)

 ZEND_API inline int add_index_resource(zval *arg, uint index, int r)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_RESOURCE;
 	tmp->value.lval = r;
 	INIT_PZVAL(tmp);
@@ -368,9 +344,8 @@ ZEND_API inline int add_index_resource(zval *arg, uint index, int r)

 ZEND_API inline int add_index_double(zval *arg, uint index, double d)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_DOUBLE;
 	tmp->value.dval = d;
 	INIT_PZVAL(tmp);
@@ -380,9 +355,8 @@ ZEND_API inline int add_index_double(zval *arg, uint index, double d)

 ZEND_API inline int add_index_string(zval *arg, uint index, char *str, int duplicate)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_STRING;
 	tmp->value.str.len = strlen(str);
 	if (duplicate) {
@@ -397,9 +371,8 @@ ZEND_API inline int add_index_string(zval *arg, uint index, char *str, int dupli

 ZEND_API inline int add_index_stringl(zval *arg, uint index, char *str, uint length, int duplicate)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_STRING;
 	tmp->value.str.len = length;
 	if (duplicate) {
@@ -414,9 +387,8 @@ ZEND_API inline int add_index_stringl(zval *arg, uint index, char *str, uint len

 ZEND_API inline int add_next_index_long(zval *arg, long n)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_LONG;
 	tmp->value.lval = n;
 	INIT_PZVAL(tmp);
@@ -424,22 +396,10 @@ ZEND_API inline int add_next_index_long(zval *arg, long n)
 }


-ZEND_API inline int add_next_index_unset(zval *arg)
-{
-	zval *tmp;
-
-	ALLOC_ZVAL(tmp);
-	tmp->type = IS_NULL;
-	INIT_PZVAL(tmp);
-	return zend_hash_next_index_insert(arg->value.ht, &tmp, sizeof(zval *), NULL);
-}
-
-
 ZEND_API inline int add_next_index_bool(zval *arg, int b)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_BOOL;
 	tmp->value.lval = b;
 	INIT_PZVAL(tmp);
@@ -449,9 +409,8 @@ ZEND_API inline int add_next_index_bool(zval *arg, int b)

 ZEND_API inline int add_next_index_resource(zval *arg, int r)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_RESOURCE;
 	tmp->value.lval = r;
 	INIT_PZVAL(tmp);
@@ -461,9 +420,8 @@ ZEND_API inline int add_next_index_resource(zval *arg, int r)

 ZEND_API inline int add_next_index_double(zval *arg, double d)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_DOUBLE;
 	tmp->value.dval = d;
 	INIT_PZVAL(tmp);
@@ -473,9 +431,8 @@ ZEND_API inline int add_next_index_double(zval *arg, double d)

 ZEND_API inline int add_next_index_string(zval *arg, char *str, int duplicate)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_STRING;
 	tmp->value.str.len = strlen(str);
 	if (duplicate) {
@@ -490,9 +447,8 @@ ZEND_API inline int add_next_index_string(zval *arg, char *str, int duplicate)

 ZEND_API inline int add_next_index_stringl(zval *arg, char *str, uint length, int duplicate)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_STRING;
 	tmp->value.str.len = length;
 	if (duplicate) {
@@ -507,9 +463,8 @@ ZEND_API inline int add_next_index_stringl(zval *arg, char *str, uint length, in

 ZEND_API inline int add_get_assoc_string(zval *arg, char *key, char *str, void **dest, int duplicate)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_STRING;
 	tmp->value.str.len = strlen(str);
 	if (duplicate) {
@@ -524,9 +479,8 @@ ZEND_API inline int add_get_assoc_string(zval *arg, char *key, char *str, void *

 ZEND_API inline int add_get_assoc_stringl(zval *arg, char *key, char *str, uint length, void **dest, int duplicate)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_STRING;
 	tmp->value.str.len = length;
 	if (duplicate) {
@@ -541,9 +495,8 @@ ZEND_API inline int add_get_assoc_stringl(zval *arg, char *key, char *str, uint

 ZEND_API inline int add_get_index_long(zval *arg, uint index, long l, void **dest)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_LONG;
 	tmp->value.lval = l;
 	INIT_PZVAL(tmp);
@@ -553,9 +506,8 @@ ZEND_API inline int add_get_index_long(zval *arg, uint index, long l, void **des

 ZEND_API inline int add_get_index_double(zval *arg, uint index, double d, void **dest)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_DOUBLE;
 	tmp->value.dval= d;
 	INIT_PZVAL(tmp);
@@ -565,9 +517,8 @@ ZEND_API inline int add_get_index_double(zval *arg, uint index, double d, void *

 ZEND_API inline int add_get_index_string(zval *arg, uint index, char *str, void **dest, int duplicate)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_STRING;
 	tmp->value.str.len = strlen(str);
 	if (duplicate) {
@@ -582,9 +533,8 @@ ZEND_API inline int add_get_index_string(zval *arg, uint index, char *str, void

 ZEND_API inline int add_get_index_stringl(zval *arg, uint index, char *str, uint length, void **dest, int duplicate)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_STRING;
 	tmp->value.str.len = length;
 	if (duplicate) {
@@ -599,41 +549,18 @@ ZEND_API inline int add_get_index_stringl(zval *arg, uint index, char *str, uint

 ZEND_API inline int add_property_long(zval *arg, char *key, long n)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_LONG;
 	tmp->value.lval = n;
 	INIT_PZVAL(tmp);
 	return zend_hash_update(arg->value.obj.properties, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
 }

-ZEND_API inline int add_property_bool(zval *arg, char *key, int b)
-{
-	zval *tmp;
-
-	ALLOC_ZVAL(tmp);
-	tmp->type = IS_BOOL;
-	tmp->value.lval = b;
-	INIT_PZVAL(tmp);
-	return zend_hash_update(arg->value.obj.properties, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
-}
-
-ZEND_API inline int add_property_unset(zval *arg, char *key)
-{
-	zval *tmp;
-
-	ALLOC_ZVAL(tmp);
-	tmp->type = IS_NULL;
-	INIT_PZVAL(tmp);
-	return zend_hash_update(arg->value.obj.properties, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
-}
-
 ZEND_API inline int add_property_resource(zval *arg, char *key, long n)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_RESOURCE;
 	tmp->value.lval = n;
 	INIT_PZVAL(tmp);
@@ -643,9 +570,8 @@ ZEND_API inline int add_property_resource(zval *arg, char *key, long n)

 ZEND_API inline int add_property_double(zval *arg, char *key, double d)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_DOUBLE;
 	tmp->value.dval = d;
 	INIT_PZVAL(tmp);
@@ -655,9 +581,8 @@ ZEND_API inline int add_property_double(zval *arg, char *key, double d)

 ZEND_API inline int add_property_string(zval *arg, char *key, char *str, int duplicate)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_STRING;
 	tmp->value.str.len = strlen(str);
 	if (duplicate) {
@@ -672,9 +597,8 @@ ZEND_API inline int add_property_string(zval *arg, char *key, char *str, int dup

 ZEND_API inline int add_property_stringl(zval *arg, char *key, char *str, uint length, int duplicate)
 {
-	zval *tmp;
+	zval *tmp = (zval *) emalloc(sizeof(zval));

-	ALLOC_ZVAL(tmp);
 	tmp->type = IS_STRING;
 	tmp->value.str.len = length;
 	if (duplicate) {
@@ -687,14 +611,12 @@ ZEND_API inline int add_property_stringl(zval *arg, char *key, char *str, uint l
 }


-ZEND_API int zend_startup_module(zend_module_entry *module)
+int zend_startup_module(zend_module_entry *module)
 {
 	if (module) {
 		module->module_number = zend_next_free_module();
 		if (module->module_startup_func) {
-			ELS_FETCH();
-
-			if (module->module_startup_func(MODULE_PERSISTENT, module->module_number ELS_CC)==FAILURE) {
+			if (module->module_startup_func(MODULE_PERSISTENT, module->module_number)==FAILURE) {
 				zend_error(E_CORE_ERROR,"Unable to start %s module",module->name);
 				return FAILURE;
 			}
@@ -706,38 +628,50 @@ ZEND_API int zend_startup_module(zend_module_entry *module)
 }


+ZEND_API int _register_list_destructors(void (*list_destructor)(void *), void (*plist_destructor)(void *), int module_number)
+{
+	list_destructors_entry ld;
+	
+#if 0
+	printf("Registering destructors %d for module %d\n", list_destructors.nNextFreeElement, module_number);
+#endif
+	
+	ld.list_destructor=(void (*)(void *)) list_destructor;
+	ld.plist_destructor=(void (*)(void *)) plist_destructor;
+	ld.module_number = module_number;
+	ld.resource_id = list_destructors.nNextFreeElement;
+	
+	if (zend_hash_next_index_insert(&list_destructors,(void *) &ld,sizeof(list_destructors_entry),NULL)==FAILURE) {
+		return FAILURE;
+	}
+	return list_destructors.nNextFreeElement-1;
+}
+
+
 /* registers all functions in *library_functions in the function hash */
-int zend_register_functions(zend_function_entry *functions, HashTable *function_table, int type)
+int zend_register_functions(zend_function_entry *functions, HashTable *function_table)
 {
 	zend_function_entry *ptr = functions;
-	zend_function function;
-	zend_internal_function *internal_function = (zend_internal_function *)&function;
+	zend_internal_function internal_function;
 	int count=0,unload=0;
 	HashTable *target_function_table = function_table;
-	int error_type;
 	CLS_FETCH();

-	if (type==MODULE_PERSISTENT) {
-		error_type = E_CORE_WARNING;
-	} else {
-		error_type = E_WARNING;
-	}
-
 	if (!target_function_table) {
 		target_function_table = CG(function_table);
 	}
-	internal_function->type = ZEND_INTERNAL_FUNCTION;
+	internal_function.type = ZEND_INTERNAL_FUNCTION;
 	
 	while (ptr->fname) {
-		internal_function->handler = ptr->handler;
-		internal_function->arg_types = ptr->func_arg_types;
-		internal_function->function_name = ptr->fname;
-		if (!internal_function->handler) {
-			zend_error(error_type, "Null function defined as active function");
+		internal_function.handler = ptr->handler;
+		internal_function.arg_types = ptr->func_arg_types;
+		internal_function.function_name = ptr->fname;
+		if (!internal_function.handler) {
+			zend_error(E_CORE_WARNING,"Null function defined as active function");
 			zend_unregister_functions(functions, count, target_function_table);
 			return FAILURE;
 		}
-		if (zend_hash_add(target_function_table, ptr->fname, strlen(ptr->fname)+1, &function, sizeof(zend_function), NULL) == FAILURE) {
+		if (zend_hash_add(target_function_table, ptr->fname, strlen(ptr->fname)+1, &internal_function, sizeof(zend_internal_function), NULL) == FAILURE) {
 			unload=1;
 			break;
 		}
@@ -747,7 +681,7 @@ int zend_register_functions(zend_function_entry *functions, HashTable *function_
 	if (unload) { /* before unloading, display all remaining bad function in the module */
 		while (ptr->fname) {
 			if (zend_hash_exists(target_function_table, ptr->fname, strlen(ptr->fname)+1)) {
-				zend_error(error_type, "Function registration failed - duplicate name - %s",ptr->fname);
+				zend_error(E_CORE_WARNING, "Function registration failed - duplicate name - %s",ptr->fname);
 			}
 			ptr++;
 		}
@@ -789,7 +723,7 @@ ZEND_API int zend_register_module(zend_module_entry *module)
 #if 0
 	zend_printf("%s:  Registering module %d\n",module->name, module->module_number);
 #endif
-	if (module->functions && zend_register_functions(module->functions, NULL, module->type)==FAILURE) {
+	if (module->functions && zend_register_functions(module->functions, NULL)==FAILURE) {
 		zend_error(E_CORE_WARNING,"%s:  Unable to register functions, unable to load",module->name);
 		return FAILURE;
 	}
@@ -801,12 +735,17 @@ ZEND_API int zend_register_module(zend_module_entry *module)
 void module_destructor(zend_module_entry *module)
 {
 	if (module->type == MODULE_TEMPORARY) {
-		zend_clean_module_rsrc_dtors(module->module_number);
+		zend_hash_apply_with_argument(&list_destructors, (int (*)(void *,void *)) clean_module_resource_destructors, (void *) &(module->module_number));
 		clean_module_constants(module->module_number);
-		if (module->request_shutdown_func)
-			module->request_shutdown_func(module->type, module->module_number);
 	}

+	if (module->request_started && module->request_shutdown_func) {
+#if 0
+		zend_printf("%s:  Request shutdown\n",module->name);
+#endif
+		module->request_shutdown_func(module->type, module->module_number);
+	}
+	module->request_started=0;
 	if (module->module_started && module->module_shutdown_func) {
 #if 0
 		zend_printf("%s:  Module shutdown\n",module->name);
@@ -829,17 +768,13 @@ void module_destructor(zend_module_entry *module)
 /* call request startup for all modules */
 int module_registry_request_startup(zend_module_entry *module)
 {
-	if (module->request_startup_func) {
-		ELS_FETCH();
-
+	if (!module->request_started && module->request_startup_func) {
 #if 0
 		zend_printf("%s:  Request startup\n",module->name);
 #endif
-		if (module->request_startup_func(module->type, module->module_number ELS_CC)==FAILURE) {
-			zend_error(E_WARNING, "request_startup() for %s module failed", module->name);
-			exit(1);
-		}
+		module->request_startup_func(module->type, module->module_number);
 	}
+	module->request_started=1;
 	return 0;
 }

@@ -851,12 +786,13 @@ int module_registry_cleanup(zend_module_entry *module)
 {
 	switch(module->type) {
 		case MODULE_PERSISTENT:
-			if (module->request_shutdown_func) {
+			if (module->request_started && module->request_shutdown_func) {
 #if 0
 				zend_printf("%s:  Request shutdown\n",module->name);
 #endif
 				module->request_shutdown_func(module->type, module->module_number);
 			}
+			module->request_started=0;
 			return 0;
 			break;
 		case MODULE_TEMPORARY:
@@ -873,31 +809,8 @@ int zend_next_free_module(void)
 	return ++module_count;
 }

-/* If parent_ce is not NULL then it inherits from parent_ce
- * If parent_ce is NULL and parent_name isn't then it looks for the parent and inherits from it
- * If both parent_ce and parent_name are NULL it does a regular class registration
- * If parent_name is specified but not found NULL is returned
- */
-ZEND_API zend_class_entry *zend_register_internal_class_ex(zend_class_entry *class_entry, zend_class_entry *parent_ce, char *parent_name)
-{
-	zend_class_entry *register_class;
-	CLS_FETCH();

-	if (!parent_ce && parent_name) {
-			if (zend_hash_find(CG(class_table), parent_name, strlen(parent_name)+1, (void **) &parent_ce)==FAILURE) {
-				return NULL;
-			}
-	}
-
-	register_class = zend_register_internal_class(class_entry);
-
-	if (parent_ce) {
-		zend_do_inheritance(register_class, parent_ce);
-	}
-	return register_class;
-}
-
-ZEND_API zend_class_entry *zend_register_internal_class(zend_class_entry *class_entry)
+ZEND_API zend_class_entry *register_internal_class(zend_class_entry *class_entry)
 {
 	zend_class_entry *register_class;
 	char *lowercase_name = zend_strndup(class_entry->name, class_entry->name_length);
@@ -909,17 +822,15 @@ ZEND_API zend_class_entry *zend_register_internal_class(zend_class_entry *class_
 	class_entry->parent = NULL;
 	class_entry->refcount = (int *) malloc(sizeof(int));
 	*class_entry->refcount = 1;
-	class_entry->constants_updated = 0;
-	zend_hash_init(&class_entry->default_properties, 0, NULL, ZVAL_PTR_DTOR, 1);
+	zend_hash_init(&class_entry->default_properties, 0, NULL, PVAL_PTR_DTOR, 1);
 	zend_hash_init(&class_entry->function_table, 0, NULL, ZEND_FUNCTION_DTOR, 1);

-
-	if (class_entry->builtin_functions) {
-		zend_register_functions(class_entry->builtin_functions, &class_entry->function_table, MODULE_PERSISTENT);
-	}
-
 	zend_hash_update(CG(class_table), lowercase_name, class_entry->name_length+1, class_entry, sizeof(zend_class_entry), (void **) &register_class);
 	free(lowercase_name);
+	
+	if (class_entry->builtin_functions) {
+		zend_register_functions(class_entry->builtin_functions, &class_entry->function_table);
+	}
 	return register_class;
 }

@@ -934,51 +845,3 @@ ZEND_API zend_module_entry *zend_get_module(int module_number)
 		return NULL;
 	}
 }
-
-ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
-                                  int is_ref, int num_symbol_tables, ...)
-{
-    HashTable  *symbol_table;
-    va_list     symbol_table_list;
-
-    if (num_symbol_tables <= 0) return FAILURE;
-
-    symbol->is_ref = is_ref;
-
-    va_start(symbol_table_list, num_symbol_tables);
-    while(num_symbol_tables-- > 0) {
-        symbol_table = va_arg(symbol_table_list, HashTable *);
-        zend_hash_update(symbol_table, name, name_length + 1, &symbol, sizeof(zval *), NULL);
-        zval_add_ref(&symbol);
-    }
-    va_end(symbol_table_list);
-    return SUCCESS;
-}
-
-
-
-
-/* Disabled functions support */
-
-static ZEND_FUNCTION(display_disabled_function)
-{
-	zend_error(E_WARNING, "%s() has been disabled for security reasons.", get_active_function_name());
-}
-
-
-static zend_function_entry disabled_function[] =  {
-	ZEND_FE(display_disabled_function,			NULL)
-	{ NULL, NULL, NULL }
-};
-
-
-ZEND_API int zend_disable_function(char *function_name, uint function_name_length)
-{
-	CLS_FETCH();
-
-	if (zend_hash_del(CG(function_table), function_name, function_name_length+1)==FAILURE) {
-		return FAILURE;
-	}
-	disabled_function[0].fname = function_name;
-	return zend_register_functions(disabled_function, CG(function_table), MODULE_PERSISTENT);
-}
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -18,64 +18,18 @@
 */


-#ifndef ZEND_API_H
-#define ZEND_API_H
+#ifndef _ZEND_API_H
+#define _ZEND_API_H

 #include "modules.h"
 #include "zend_list.h"
-#include "zend_fast_cache.h"
-#include "zend_operators.h"
-#include "zend_variables.h"
-#include "zend_execute.h"

-#define ZEND_FN(name) zend_if_##name
+
 #define ZEND_NAMED_FUNCTION(name) void name(INTERNAL_FUNCTION_PARAMETERS)
-#define ZEND_FUNCTION(name) ZEND_NAMED_FUNCTION(ZEND_FN(name))
-
-#define ZEND_NAMED_FE(zend_name, name, arg_types) { #zend_name, name, arg_types },
-#define ZEND_FE(name, arg_types) ZEND_NAMED_FE(name, ZEND_FN(name), arg_types)
-#define ZEND_FALIAS(name, alias, arg_types) ZEND_NAMED_FE(name, ZEND_FN(alias), arg_types)
-
-#define ZEND_MINIT(module)       zend_minit_##module
-#define ZEND_MSHUTDOWN(module)   zend_mshutdown_##module
-#define ZEND_RINIT(module)       zend_rinit_##module
-#define ZEND_RSHUTDOWN(module)   zend_rshutdown_##module
-#define ZEND_MINFO(module)       zend_info_##module
-#define ZEND_GINIT(module)       zend_ginit_##module
-#define ZEND_GSHUTDOWN(module)   zend_gshutdown_##module
-
-#define ZEND_MINIT_FUNCTION(module)      int ZEND_MINIT(module)(INIT_FUNC_ARGS)
-#define ZEND_MSHUTDOWN_FUNCTION(module)  int ZEND_MSHUTDOWN(module)(SHUTDOWN_FUNC_ARGS)
-#define ZEND_RINIT_FUNCTION(module)      int ZEND_RINIT(module)(INIT_FUNC_ARGS)
-#define ZEND_RSHUTDOWN_FUNCTION(module)  int ZEND_RSHUTDOWN(module)(SHUTDOWN_FUNC_ARGS)
-#define ZEND_MINFO_FUNCTION(module)      void ZEND_MINFO(module)(ZEND_MODULE_INFO_FUNC_ARGS)
-#define ZEND_GINIT_FUNCTION(module)      int ZEND_GINIT(module)(GINIT_FUNC_ARGS)
-#define ZEND_GSHUTDOWN_FUNCTION(module)  int ZEND_GSHUTDOWN(module)(void)
-
-#define ZEND_GET_MODULE(name) \
-	ZEND_DLEXPORT zend_module_entry *get_module(void) { return &name##_module_entry; }
-
-#define ZEND_BEGIN_MODULE_GLOBALS(module_name)		\
-	typedef struct _zend_##module_name##_globals {
-#define ZEND_END_MODULE_GLOBALS(module_name)		\
-	} zend_##module_name##_globals;
-
-#ifdef ZTS
-
-#define ZEND_DECLARE_MODULE_GLOBALS(module_name)							\
-	static ts_rsrc_id module_name##_globals_id;
-#define ZEND_INIT_MODULE_GLOBALS(module_name, globals_ctor, globals_dtor)	\
-	module_name##_globals_id = ts_allocate_id(sizeof(zend_##module_name##_globals), (ts_allocate_ctor) globals_ctor, (ts_allocate_dtor) globals_dtor);
-
-#else
-
-#define ZEND_DECLARE_MODULE_GLOBALS(module_name)							\
-	static zend_##module_name##_globals module_name##_globals;
-#define ZEND_INIT_MODULE_GLOBALS(module_name, globals_ctor, globals_dtor)	\
-	globals_ctor(&module_name##_globals);
-
-#endif
+#define ZEND_FUNCTION(name) ZEND_NAMED_FUNCTION(zend_if_##name)

+#define ZEND_NAMED_FE(runtime_name, name, arg_types) { #runtime_name, name, arg_types },
+#define ZEND_FE(name, arg_types) ZEND_NAMED_FE(name, zend_if_##name, arg_types)


 #define INIT_CLASS_ENTRY(class_container, class_name, functions)	\
@@ -102,52 +56,46 @@

 int zend_next_free_module(void);

-ZEND_API int zend_get_parameters(int ht, int param_count, ...);
-ZEND_API int zend_get_parameters_array(int ht, int param_count, zval **argument_array);
-ZEND_API int zend_get_parameters_ex(int param_count, ...);
-ZEND_API int zend_get_parameters_array_ex(int param_count, zval ***argument_array);
+ZEND_API int getParameters(int ht, int param_count,...);
+ZEND_API int getParametersArray(int ht, int param_count, zval **argument_array);
+ZEND_API int getParametersEx(int param_count,...);
+ZEND_API int getParametersArrayEx(int param_count, zval ***argument_array);

 ZEND_API int ParameterPassedByReference(int ht, uint n);

-int zend_register_functions(zend_function_entry *functions, HashTable *function_table, int type);
+int zend_register_functions(zend_function_entry *functions, HashTable *function_table);
 void zend_unregister_functions(zend_function_entry *functions, int count, HashTable *function_table);
 ZEND_API int zend_register_module(zend_module_entry *module_entry);
-
-ZEND_API zend_class_entry *zend_register_internal_class(zend_class_entry *class_entry);
-ZEND_API zend_class_entry *zend_register_internal_class_ex(zend_class_entry *class_entry, zend_class_entry *parent_ce, char *parent_name);
-
+ZEND_API zend_class_entry *register_internal_class(zend_class_entry *class_entry);
 ZEND_API zend_module_entry *zend_get_module(int module_number);
-ZEND_API int zend_disable_function(char *function_name, uint function_name_length);

 ZEND_API void wrong_param_count(void);

 #define getThis() (this_ptr)

-#define WRONG_PARAM_COUNT					ZEND_WRONG_PARAM_COUNT()
-#define WRONG_PARAM_COUNT_WITH_RETVAL(ret)	ZEND_WRONG_PARAM_COUNT_WITH_RETVAL(ret)
-#define ARG_COUNT(dummy)	(ht)
-#define ZEND_NUM_ARGS()		(ht)
-#define ZEND_WRONG_PARAM_COUNT()					{ wrong_param_count(); return; }
-#define ZEND_WRONG_PARAM_COUNT_WITH_RETVAL(ret)		{ wrong_param_count(); return ret; }
+#define WRONG_PARAM_COUNT { wrong_param_count(); return; }
+#define WRONG_PARAM_COUNT_WITH_RETVAL(ret) { wrong_param_count(); return ret; }
+#define ARG_COUNT(ht) (ht)

-#ifndef ZEND_WIN32
+#define BYREF_NONE 0
+#define BYREF_FORCE 1
+#define BYREF_ALLOW 2
+#define BYREF_FORCE_REST 3
+
+#if !(WIN32||WINNT)
 #define DLEXPORT
 #endif

-ZEND_API int zend_startup_module(zend_module_entry *module);
+int zend_startup_module(zend_module_entry *module);

-#define array_init(arg)			_array_init((arg) ZEND_FILE_LINE_CC)
-#define object_init(arg)		_object_init((arg) ZEND_FILE_LINE_CC)
-#define object_init_ex(arg, ce)	_object_init_ex((arg), (ce) ZEND_FILE_LINE_CC)
-ZEND_API int _array_init(zval *arg ZEND_FILE_LINE_DC);
-ZEND_API int _object_init(zval *arg ZEND_FILE_LINE_DC);
-ZEND_API int _object_init_ex(zval *arg, zend_class_entry *ce ZEND_FILE_LINE_DC);
+ZEND_API int array_init(zval *arg);
+ZEND_API int object_init(zval *arg);
+ZEND_API int object_init_ex(zval *arg, zend_class_entry *ce);

 /* no longer supported */
 ZEND_API int add_assoc_function(zval *arg, char *key,void (*function_ptr)(INTERNAL_FUNCTION_PARAMETERS));

 ZEND_API int add_assoc_long(zval *arg, char *key, long n);
-ZEND_API int add_assoc_unset(zval *arg, char *key);
 ZEND_API int add_assoc_bool(zval *arg, char *key, int b);
 ZEND_API int add_assoc_resource(zval *arg, char *key, int r);
 ZEND_API int add_assoc_double(zval *arg, char *key, double d);
@@ -155,7 +103,6 @@ ZEND_API int add_assoc_string(zval *arg, char *key, char *str, int duplicate);
 ZEND_API int add_assoc_stringl(zval *arg, char *key, char *str, uint length, int duplicate);

 ZEND_API int add_index_long(zval *arg, uint idx, long n);
-ZEND_API int add_index_unset(zval *arg, uint idx);
 ZEND_API int add_index_bool(zval *arg, uint idx, int b);
 ZEND_API int add_index_resource(zval *arg, uint idx, int r);
 ZEND_API int add_index_double(zval *arg, uint idx, double d);
@@ -163,7 +110,6 @@ ZEND_API int add_index_string(zval *arg, uint idx, char *str, int duplicate);
 ZEND_API int add_index_stringl(zval *arg, uint idx, char *str, uint length, int duplicate);

 ZEND_API int add_next_index_long(zval *arg, long n);
-ZEND_API int add_next_index_unset(zval *arg);
 ZEND_API int add_next_index_bool(zval *arg, int b);
 ZEND_API int add_next_index_resource(zval *arg, int r);
 ZEND_API int add_next_index_double(zval *arg, double d);
@@ -177,74 +123,21 @@ ZEND_API int add_get_assoc_stringl(zval *arg, char *key, char *str, uint length,
 ZEND_API int add_get_index_string(zval *arg, uint idx, char *str, void **dest, int duplicate);
 ZEND_API int add_get_index_stringl(zval *arg, uint idx, char *str, uint length, void **dest, int duplicate);

-ZEND_API int call_user_function(HashTable *function_table, zval *object, zval *function_name, zval *retval_ptr, int param_count, zval *params[]);
-ZEND_API int call_user_function_ex(HashTable *function_table, zval *object, zval *function_name, zval **retval_ptr_ptr, int param_count, zval **params[], int no_separation, HashTable *symbol_table);
+ZEND_API int call_user_function(HashTable *function_table, zval *object, zval *function_name, zval *retval, int param_count, zval *params[]);
+ZEND_API int call_user_function_ex(HashTable *function_table, zval *object, zval *function_name, zval *retval, int param_count, zval **params[], int no_separation);

 ZEND_API int add_property_long(zval *arg, char *key, long l);
-ZEND_API int add_property_unset(zval *arg, char *key);
-ZEND_API int add_property_bool(zval *arg, char *key, int b);
 ZEND_API int add_property_resource(zval *arg, char *key, long r);
 ZEND_API int add_property_double(zval *arg, char *key, double d);
 ZEND_API int add_property_string(zval *arg, char *key, char *str, int duplicate);
 ZEND_API int add_property_stringl(zval *arg, char *key, char *str, uint length, int duplicate);

-ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
-                                  int is_ref, int num_symbol_tables, ...);
-
 #define add_method(arg,key,method)	add_assoc_function((arg),(key),(method))

-#define ZVAL_RESOURCE(z,l) {			\
-		(z)->type = IS_RESOURCE;        \
-		(z)->value.lval = l;	        \
-	}
-#define ZVAL_BOOL(z,b) {				\
-		(z)->type = IS_BOOL;	        \
-		(z)->value.lval = b;	        \
-	}
-#define ZVAL_NULL(z) {					\
-		(z)->type = IS_NULL;	        \
-	}
-#define ZVAL_LONG(z,l) {				\
-		(z)->type = IS_LONG;	        \
-		(z)->value.lval = l;	        \
-	}
-#define ZVAL_DOUBLE(z,d) {				\
-		(z)->type = IS_DOUBLE;	        \
-		(z)->value.dval = d;	        \
-	}
-#define ZVAL_STRING(z,s,duplicate) {	\
-		char *__s=(s);					\
-		(z)->value.str.len = strlen(__s);	\
-		(z)->value.str.val = (duplicate?estrndup(__s,(z)->value.str.len):__s);	\
-		(z)->type = IS_STRING;	        \
-	}
-#define ZVAL_STRINGL(z,s,l,duplicate) {	\
-		char *__s=(s); int __l=l;		\
-		(z)->value.str.len = __l;	    \
-		(z)->value.str.val = (duplicate?estrndup(__s,__l):__s);	\
-		(z)->type = IS_STRING;		    \
-	}
-
-#define ZVAL_EMPTY_STRING(z) {	        \
-		(z)->value.str.len = 0;  	    \
-		(z)->value.str.val = empty_string; \
-		(z)->type = IS_STRING;		    \
-	}
-
-#define ZVAL_FALSE  { (z)->value.lval = 0;  (z)->type = IS_BOOL; }
-#define ZVAL_TRUE   { (z)->value.lval = 1;  (z)->type = IS_BOOL; }
-
 #define RETVAL_RESOURCE(l) {			\
 		return_value->type = IS_RESOURCE;\
 		return_value->value.lval = l;	\
 	}
-#define RETVAL_BOOL(b) {				\
-		return_value->type = IS_BOOL;	\
-		return_value->value.lval = b;	\
-	}
-#define RETVAL_NULL() {					\
-		return_value->type = IS_NULL;	\
-	}
 #define RETVAL_LONG(l) {				\
 		return_value->type = IS_LONG;	\
 		return_value->value.lval = l;	\
@@ -266,12 +159,6 @@ ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
 		return_value->type = IS_STRING;		\
 	}

-#define RETVAL_EMPTY_STRING() {	            \
-		return_value->value.str.len = 0;  	\
-		return_value->value.str.val = empty_string; \
-		return_value->type = IS_STRING;		\
-	}
-
 #define RETVAL_FALSE  { return_value->value.lval = 0;  return_value->type = IS_BOOL; }
 #define RETVAL_TRUE   { return_value->value.lval = 1;  return_value->type = IS_BOOL; }

@@ -280,18 +167,6 @@ ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
 		return_value->value.lval = l;	\
 		return;							\
 	}
-
-#define RETURN_BOOL(b) {				\
-		return_value->type = IS_BOOL;	\
-		return_value->value.lval = b;	\
-		return;							\
-	}
-
-#define RETURN_NULL() {				\
-		return_value->type = IS_NULL;	\
-		return;							\
-	}
-
 #define RETURN_LONG(l) {				\
 		return_value->type = IS_LONG;	\
 		return_value->value.lval = l;	\
@@ -317,22 +192,14 @@ ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
 		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;																\
+									zval *var = (zval *) emalloc(sizeof(zval));								\
 									char *str=(v); /* prevent 'v' from being evaluated more than once */	\
 																											\
-									ALLOC_ZVAL(var);														\
 									var->value.str.val = (str);												\
 									var->value.str.len = strlen((str));										\
 									var->type = IS_STRING;													\
@@ -342,9 +209,8 @@ ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,

 #define SET_VAR_STRINGL(n,v,l)	{														\
 									{													\
-										zval *var;										\
+										zval *var = (zval *) emalloc(sizeof(zval));		\
 																						\
-										ALLOC_ZVAL(var);								\
 										var->value.str.val = (v);						\
 										var->value.str.len = (l);						\
 										var->type = IS_STRING;							\
@@ -354,9 +220,8 @@ ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,

 #define SET_VAR_LONG(n,v)	{															\
 								{														\
-									zval *var;											\
+									zval *var = (zval *) emalloc(sizeof(zval));			\
 																						\
-									ALLOC_ZVAL(var);									\
 									var->value.lval = (v);								\
 									var->type = IS_LONG;								\
 									ZEND_SET_GLOBAL_VAR(n, var);						\
@@ -365,9 +230,8 @@ ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,

 #define SET_VAR_DOUBLE(n,v)	{															\
 								{														\
-									zval *var;											\
+									zval *var = (zval *) emalloc(sizeof(zval));			\
 																						\
-									ALLOC_ZVAL(var);									\
 									var->value.dval = (v);								\
 									var->type = IS_DOUBLE;								\
 									ZEND_SET_GLOBAL_VAR(n, var);						\
@@ -375,34 +239,29 @@ ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
 							}


-#define ZEND_SET_SYMBOL(symtable, name, var)										\
-	{																				\
-		char *_name = (name);														\
-																					\
-		ZEND_SET_SYMBOL_WITH_LENGTH(symtable, _name, strlen(_name)+1, var, 1, 0);	\
+#define ZEND_SET_SYMBOL(symtable, name, var)									\
+	{																			\
+		char *_name = (name);													\
+																				\
+		ZEND_SET_SYMBOL_WITH_LENGTH(symtable, _name, strlen(_name)+1, var);		\
 	}

-#define ZEND_SET_SYMBOL_WITH_LENGTH(symtable, name, name_length, var, _refcount, _is_ref)				\
+
+#define ZEND_SET_SYMBOL_WITH_LENGTH(symtable, name, name_length, var)									\
 	{																									\
 		zval **orig_var;																				\
 																										\
 		if (zend_hash_find(symtable, (name), (name_length), (void **) &orig_var)==SUCCESS				\
 			&& PZVAL_IS_REF(*orig_var)) {																\
-			(var)->refcount = (*orig_var)->refcount;													\
+			(var)->refcount = (*orig_var)->refcount;														\
 			(var)->is_ref = 1;																			\
 																										\
-			if (_refcount) {																			\
-				(var)->refcount += _refcount-1;															\
-			}																							\
 			zval_dtor(*orig_var);																		\
-			**orig_var = *(var);																		\
-			FREE_ZVAL(var);																					\
+			**orig_var = *(var);																			\
+			efree(var);																					\
 		} else {																						\
-			(var)->is_ref = _is_ref;																	\
-			if (_refcount) {																			\
-				(var)->refcount = _refcount;															\
-			}																							\
-			zend_hash_update(symtable, (name), (name_length), &(var), sizeof(zval *), NULL);			\
+			INIT_PZVAL((var));																			\
+			zend_hash_update(symtable, (name), (name_length), &(var), sizeof(zval *), NULL);				\
 		}																								\
 	}

@@ -410,13 +269,12 @@ ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
 #define ZEND_SET_GLOBAL_VAR(name, var)				\
 	ZEND_SET_SYMBOL(&EG(symbol_table), name, var)

-#define ZEND_SET_GLOBAL_VAR_WITH_LENGTH(name, name_length, var, _refcount, _is_ref)		\
-	ZEND_SET_SYMBOL_WITH_LENGTH(&EG(symbol_table), name, name_length, var, _refcount, _is_ref)
+#define ZEND_SET_GLOBAL_VAR_WITH_LENGTH(name, name_length, var)		\
+	ZEND_SET_SYMBOL_WITH_LENGTH(&EG(symbol_table), name, name_length, var)

 #define HASH_OF(p) ((p)->type==IS_ARRAY ? (p)->value.ht : (((p)->type==IS_OBJECT ? (p)->value.obj.properties : NULL)))
-#define ZVAL_IS_NULL(z) ((z)->type==IS_NULL)

-#endif /* ZEND_API_H */
+#endif							/* _ZEND_API_H */

 /*
 * Local variables:
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -23,7 +23,6 @@
 #include "zend.h"
 #include "zend_alloc.h"
 #include "zend_globals.h"
-#include "zend_fast_cache.h"
 #ifdef HAVE_SIGNAL_H
 # include <signal.h>
 #endif
@@ -32,13 +31,10 @@
 #endif

 #ifndef ZTS
-ZEND_API zend_alloc_globals alloc_globals;
+static zend_alloc_globals alloc_globals;
 #endif


-#define ZEND_DISABLE_MEMORY_CACHE 0
-
-
 #if ZEND_DEBUG
 # define END_MAGIC_SIZE sizeof(long)
 # define END_ALIGNMENT(size) (((size)%PLATFORM_ALIGNMENT)?(PLATFORM_ALIGNMENT-((size)%PLATFORM_ALIGNMENT)):0)
@@ -50,31 +46,24 @@ ZEND_API zend_alloc_globals alloc_globals;

 # if MEMORY_LIMIT
 #  if ZEND_DEBUG
-#define CHECK_MEMORY_LIMIT(s, rs) _CHECK_MEMORY_LIMIT(s, rs, __zend_filename, __zend_lineno)
+#define CHECK_MEMORY_LIMIT(s) _CHECK_MEMORY_LIMIT(s ZEND_FILE_LINE_RELAY_CC)
 #  else
-#define CHECK_MEMORY_LIMIT(s, rs)	_CHECK_MEMORY_LIMIT(s, rs, NULL,0)
+#define CHECK_MEMORY_LIMIT(s)	_CHECK_MEMORY_LIMIT(s,NULL,0)
 #  endif

-#define _CHECK_MEMORY_LIMIT(s, rs, file, lineno) { AG(allocated_memory) += rs;\
+#define _CHECK_MEMORY_LIMIT(s,file,lineno) { AG(allocated_memory) += (s);\
 								if (AG(memory_limit)<AG(allocated_memory)) {\
-									if ((AG(memory_limit)+1048576)<AG(allocated_memory)) { \
-										/* failed to handle this gracefully, exit() */ \
-										exit(1);	\
-									}	\
-									if (!AG(memory_exhausted)) {	\
-										if (!file) { \
-											zend_error(E_ERROR,"Allowed memory size of %d bytes exhausted (tried to allocate %d bytes)", AG(memory_limit),s); \
-										} else { \
-											zend_error(E_ERROR,"Allowed memory size of %d bytes exhausted at %s:%d (tried to allocate %d bytes)", AG(memory_limit), file, lineno, s); \
-										} \
-										AG(memory_exhausted)=1;	\
-									}	\
+									if (!file) { \
+										zend_error(E_ERROR,"Allowed memory size of %d bytes exhausted (tried to allocate %d bytes)", AG(memory_limit),s); \
+									} else { \
+										zend_error(E_ERROR,"Allowed memory size of %d bytes exhausted at %s:%d (tried to allocate %d bytes)", AG(memory_limit), file, lineno, s); \
+									} \
 								} \
 							}
 # endif

 #ifndef CHECK_MEMORY_LIMIT
-#define CHECK_MEMORY_LIMIT(s, rs)
+#define CHECK_MEMORY_LIMIT(s)
 #endif


@@ -104,32 +93,19 @@ ZEND_API zend_alloc_globals alloc_globals;
 		}							\
 		AG(head) = p;				\
 	}								\
-	p->pLast = (zend_mem_header *) NULL;
+	p->pLast = (mem_header *) NULL;

-#define DECLARE_CACHE_VARS		\
-	unsigned int real_size;		\
-	unsigned int cache_index;

-#define REAL_SIZE(size) ((size+7) & ~0x7)
-
-#define CALCULATE_REAL_SIZE_AND_CACHE_INDEX(size)	\
-	real_size = REAL_SIZE(size);				\
-	cache_index = real_size >> 3;
-
-#define SIZE real_size
-
-#define CACHE_INDEX cache_index

 ZEND_API void *_emalloc(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
 {
-	zend_mem_header *p;
-	DECLARE_CACHE_VARS
+	mem_header *p;
 	ALS_FETCH();

-	CALCULATE_REAL_SIZE_AND_CACHE_INDEX(size);
+	HANDLE_BLOCK_INTERRUPTIONS();

-	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 ((size < MAX_CACHED_MEMORY) && (AG(cache_count)[size] > 0)) {
+		p = AG(cache)[size][--AG(cache_count)[size]];
 #if ZEND_DEBUG
 		p->filename = __zend_filename;
 		p->lineno = __zend_lineno;
@@ -137,29 +113,15 @@ 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]++;
 #endif
+		HANDLE_UNBLOCK_INTERRUPTIONS();
 		p->persistent = 0;
 		p->cached = 0;
-		p->size = size;
-		HANDLE_BLOCK_INTERRUPTIONS();
-		ADD_POINTER_TO_LIST(p);
-		HANDLE_UNBLOCK_INTERRUPTIONS();
-		return (void *)((char *)p + sizeof(zend_mem_header) + PLATFORM_PADDING);
+		return (void *)((char *)p + sizeof(mem_header) + PLATFORM_PADDING);
 	} else {
-#if ZEND_DEBUG
-		if (CACHE_INDEX<MAX_CACHED_MEMORY) {
-			AG(cache_stats)[CACHE_INDEX][0]++;
-		}
-#endif
-		p  = (zend_mem_header *) malloc(sizeof(zend_mem_header) + SIZE + PLATFORM_PADDING + END_ALIGNMENT(SIZE) + END_MAGIC_SIZE);
+		p  = (mem_header *) malloc(sizeof(mem_header) + size + PLATFORM_PADDING + END_ALIGNMENT(size) + END_MAGIC_SIZE);
 	}

-	HANDLE_BLOCK_INTERRUPTIONS();
-
 	if (!p) {
 		fprintf(stderr,"FATAL:  emalloc():  Unable to allocate %ld bytes\n", (long) size);
 #if ZEND_DEBUG && defined(HAVE_KILL) && defined(HAVE_GETPID)
@@ -172,7 +134,7 @@ ZEND_API void *_emalloc(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
 	}
 	p->persistent = p->cached = 0;
 	ADD_POINTER_TO_LIST(p);
-	p->size = size; /* Save real size for correct cache output */
+	p->size = size;
 #if ZEND_DEBUG
 	p->filename = __zend_filename;
 	p->lineno = __zend_lineno;
@@ -180,59 +142,41 @@ 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
-	*((long *)(((char *) p) + sizeof(zend_mem_header)+SIZE+PLATFORM_PADDING+END_ALIGNMENT(SIZE))) = MEM_BLOCK_END_MAGIC;
+	*((long *)(((char *) p) + sizeof(mem_header)+size+PLATFORM_PADDING+END_ALIGNMENT(size))) = MEM_BLOCK_END_MAGIC;
 #endif
 #if MEMORY_LIMIT
-	CHECK_MEMORY_LIMIT(size, SIZE);
+	CHECK_MEMORY_LIMIT(size);
 #endif
 	HANDLE_UNBLOCK_INTERRUPTIONS();
-	return (void *)((char *)p + sizeof(zend_mem_header) + PLATFORM_PADDING);
+	return (void *)((char *)p + sizeof(mem_header) + PLATFORM_PADDING);
 }


 ZEND_API void _efree(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
 {
-	zend_mem_header *p = (zend_mem_header *) ((char *)ptr - sizeof(zend_mem_header) - PLATFORM_PADDING);
-	DECLARE_CACHE_VARS
+	mem_header *p = (mem_header *) ((char *)ptr - sizeof(mem_header) - PLATFORM_PADDING);
 	ALS_FETCH();

-#if defined(ZTS) && ZEND_DEBUG
-	if (p->thread_id != tsrm_thread_id()) {
-		tsrm_error(TSRM_ERROR_LEVEL_ERROR, "Memory block allocated at %s:(%d) on thread %x freed at %s:(%d) on thread %x, ignoring",
-			p->filename, p->lineno, p->thread_id,
-			__zend_filename, __zend_lineno, tsrm_thread_id());
-		return;
-	}
-#endif
-
-	CALCULATE_REAL_SIZE_AND_CACHE_INDEX(p->size);
 #if ZEND_DEBUG
 	if (!_mem_block_check(ptr, 1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC)) {
 		return;
 	}
-	memset(ptr, 0x5a, SIZE);
+	memset(ptr, 0x5a, p->size);
 #endif

-	if (!ZEND_DISABLE_MEMORY_CACHE 
-		&& !p->persistent && (CACHE_INDEX < MAX_CACHED_MEMORY) && (AG(cache_count)[CACHE_INDEX] < MAX_CACHED_ENTRIES)) {
-		AG(cache)[CACHE_INDEX][AG(cache_count)[CACHE_INDEX]++] = p;
+	if (!p->persistent && (p->size < MAX_CACHED_MEMORY) && (AG(cache_count)[p->size] < MAX_CACHED_ENTRIES)) {
+		AG(cache)[p->size][AG(cache_count)[p->size]++] = p;
 		p->cached = 1;
 #if ZEND_DEBUG
 		p->magic = MEM_BLOCK_CACHED_MAGIC;
 #endif
-		HANDLE_BLOCK_INTERRUPTIONS();
-		REMOVE_POINTER_FROM_LIST(p);
-		HANDLE_UNBLOCK_INTERRUPTIONS();
 		return;
 	}
 	HANDLE_BLOCK_INTERRUPTIONS();
 	REMOVE_POINTER_FROM_LIST(p);

 #if MEMORY_LIMIT
-	AG(allocated_memory) -= SIZE;
+	AG(allocated_memory) -= p->size;
 #endif
 	
 	free(p);
@@ -244,14 +188,14 @@ ZEND_API void *_ecalloc(size_t nmemb, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LI
 {
 	void *p;
 	int final_size=size*nmemb;
-	
+
 	HANDLE_BLOCK_INTERRUPTIONS();
 	p = _emalloc(final_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
 	if (!p) {
 		HANDLE_UNBLOCK_INTERRUPTIONS();
 		return (void *) p;
 	}
-	memset(p,(int)NULL, final_size);
+	memset(p,(int)NULL,final_size);
 	HANDLE_UNBLOCK_INTERRUPTIONS();
 	return p;
 }
@@ -259,33 +203,16 @@ 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 *) ((char *)ptr-sizeof(zend_mem_header)-PLATFORM_PADDING);
-	zend_mem_header *orig = p;
-	DECLARE_CACHE_VARS
+	mem_header *p = (mem_header *) ((char *)ptr-sizeof(mem_header)-PLATFORM_PADDING);
+	mem_header *orig = p;
 	ALS_FETCH();

 	if (!ptr) {
 		return _emalloc(size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
 	}
-
-#if defined(ZTS) && ZEND_DEBUG
-	if (p->thread_id != tsrm_thread_id()) {
-		void *new_p;
-
-		tsrm_error(TSRM_ERROR_LEVEL_ERROR, "Memory block allocated at %s:(%d) on thread %x reallocated at %s:(%d) on thread %x, duplicating",
-			p->filename, p->lineno, p->thread_id,
-			__zend_filename, __zend_lineno, tsrm_thread_id());
-		new_p = _emalloc(size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
-		memcpy(new_p, ptr, p->size);
-		return new_p;
-	}
-#endif
-
-	CALCULATE_REAL_SIZE_AND_CACHE_INDEX(size);
-
 	HANDLE_BLOCK_INTERRUPTIONS();
 	REMOVE_POINTER_FROM_LIST(p);
-	p = (zend_mem_header *) realloc(p,sizeof(zend_mem_header)+SIZE+PLATFORM_PADDING+END_ALIGNMENT(SIZE)+END_MAGIC_SIZE);
+	p = (mem_header *) realloc(p,sizeof(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);
@@ -304,15 +231,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;
-	*((long *)(((char *) p) + sizeof(zend_mem_header)+SIZE+PLATFORM_PADDING+END_ALIGNMENT(SIZE))) = MEM_BLOCK_END_MAGIC;
+	*((long *)(((char *) p) + sizeof(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));
+	CHECK_MEMORY_LIMIT(size - p->size);
 #endif
 	p->size = size;

 	HANDLE_UNBLOCK_INTERRUPTIONS();
-	return (void *)((char *)p+sizeof(zend_mem_header)+PLATFORM_PADDING);
+	return (void *)((char *)p+sizeof(mem_header)+PLATFORM_PADDING);
 }


@@ -382,11 +309,6 @@ ZEND_API int zend_set_memory_limit(unsigned int memory_limit)

 ZEND_API void start_memory_manager(ALS_D)
 {
-#ifndef ZTS
-	int i, j;
-	void *cached_entries[MAX_CACHED_MEMORY][MAX_CACHED_ENTRIES];
-#endif
-
 	AG(phead) = AG(head) = NULL;
 	
 #if MEMORY_LIMIT
@@ -395,60 +317,25 @@ ZEND_API void start_memory_manager(ALS_D)
 	AG(memory_exhausted)=0;
 #endif

-	memset(AG(fast_cache_list_head), 0, sizeof(AG(fast_cache_list_head)));
-	memset(AG(cache_count),0,sizeof(AG(cache_count)));
-
-#ifndef ZTS
-	/* Initialize cache, to prevent fragmentation */
-	/* We can't do this in ZTS mode, because calling emalloc() from within start_memory_manager()
-	 * will yield an endless recursion calling to alloc_globals_ctor()
-	 */
-	for (i=1; i<MAX_CACHED_MEMORY; i++) {
-		for (j=0; j<PRE_INIT_CACHE_ENTRIES; j++) {
-			cached_entries[i][j] = emalloc(8*i);
-		}
-	}
-	for (i=1; i<MAX_CACHED_MEMORY; i++) {
-		for (j=0; j<PRE_INIT_CACHE_ENTRIES; j++) {
-			efree(cached_entries[i][j]);
-		}
-	}
-#endif
-
-#if ZEND_DEBUG
-	memset(AG(cache_stats), 0, sizeof(AG(cache_stats)));
-	memset(AG(fast_cache_stats), 0, sizeof(AG(fast_cache_stats)));
-#endif
+	memset(AG(cache_count),0,MAX_CACHED_MEMORY*sizeof(unsigned char));
 }


 ZEND_API void shutdown_memory_manager(int silent, int clean_cache)
 {
-	zend_mem_header *p, *t;
-	unsigned int fci, i, j;
+	mem_header *p, *t;
 #if ZEND_DEBUG
 	int had_leaks=0;
 #endif
-	zend_fast_cache_list_entry *fast_cache_list_entry, *next_fast_cache_list_entry;
 	ALS_FETCH();

-	for (fci=0; fci<MAX_FAST_CACHE_TYPES; fci++) {
-		fast_cache_list_entry = AG(fast_cache_list_head)[fci];
-		while (fast_cache_list_entry) {
-			next_fast_cache_list_entry = fast_cache_list_entry->next;
-			efree(fast_cache_list_entry);
-			fast_cache_list_entry = next_fast_cache_list_entry;
-		}
-		AG(fast_cache_list_head)[fci] = NULL;
-	}
-
 	p=AG(head);
 	t=AG(head);
 	while (t) {
 		if (!t->cached || clean_cache) {
 #if ZEND_DEBUG
 			if (!t->cached && !t->reported) {
-				zend_mem_header *iterator;
+				mem_header *iterator;
 				int total_leak=0, total_leak_count=0;

 				had_leaks=1;
@@ -469,9 +356,6 @@ ZEND_API void shutdown_memory_manager(int silent, int clean_cache)
 					zend_message_dispatcher(ZMSG_MEMORY_LEAK_REPEATED, (void *) (long) (total_leak_count));
 				}
 			}
-#endif
-#if MEMORY_LIMIT
-			AG(allocated_memory) -= t->size;
 #endif
 			p = t->pNext;
 			REMOVE_POINTER_FROM_LIST(t);
@@ -481,57 +365,6 @@ ZEND_API void shutdown_memory_manager(int silent, int clean_cache)
 			t = t->pNext;
 		}
 	}
-
-	if(clean_cache) {
-		for (i=1; i<MAX_CACHED_MEMORY; i++) {
-			for (j=0; j<AG(cache_count)[i]; j++) {
-				free(AG(cache)[i][j]);
-			}
-		}
-	}
-#if MEMORY_LIMIT
-	AG(memory_exhausted)=0;
-#endif
-
-#if (ZEND_DEBUG)
-	do {
-		zval display_memory_cache_stats;
-		int i, j;
-
-		if (clean_cache) {
-			/* we're shutting down completely, don't even touch the INI subsystem */
-			break;
-		}
-		if (zend_get_ini_entry("display_memory_cache_stats", sizeof("display_memory_cache_stats"), &display_memory_cache_stats)==FAILURE) {
-			break;
-		}
-		if (!atoi(display_memory_cache_stats.value.str.val)) {
-			break;
-		}
-		fprintf(stderr, "Memory cache statistics\n"
-						"-----------------------\n\n"
-						"[zval, %2ld]\t\t%d / %d (%.2f%%)\n"
-						"[hash, %2ld]\t\t%d / %d (%.2f%%)\n",
-						(long) sizeof(zval),
-						AG(fast_cache_stats)[ZVAL_CACHE_LIST][1], AG(fast_cache_stats)[ZVAL_CACHE_LIST][0]+AG(fast_cache_stats)[ZVAL_CACHE_LIST][1],
-						((double) AG(fast_cache_stats)[ZVAL_CACHE_LIST][1] / (AG(fast_cache_stats)[ZVAL_CACHE_LIST][0]+AG(fast_cache_stats)[ZVAL_CACHE_LIST][1]))*100,
-						(long) sizeof(HashTable),
-						AG(fast_cache_stats)[HASHTABLE_CACHE_LIST][1], AG(fast_cache_stats)[HASHTABLE_CACHE_LIST][0]+AG(fast_cache_stats)[HASHTABLE_CACHE_LIST][1],
-						((double) AG(fast_cache_stats)[HASHTABLE_CACHE_LIST][1] / (AG(fast_cache_stats)[HASHTABLE_CACHE_LIST][0]+AG(fast_cache_stats)[HASHTABLE_CACHE_LIST][1]))*100);
-
-
-		for (i=0; i<MAX_CACHED_MEMORY; i+=2) {
-			fprintf(stderr, "[%2d, %2d]\t\t", i, i+1);
-			for (j=0; j<2; j++) {
-				fprintf(stderr, "%d / %d (%.2f%%)\t\t",
-						AG(cache_stats)[i+j][1], AG(cache_stats)[i+j][0]+AG(cache_stats)[i+j][1],
-						((double) AG(cache_stats)[i+j][1] / (AG(cache_stats)[i+j][0]+AG(cache_stats)[i+j][1]))*100);
-			}
-			fprintf(stderr, "\n");
-		}
-					
-	} while (0);
-#endif
 }


@@ -545,17 +378,17 @@ void zend_debug_alloc_output(char *format, ...)
 	vsprintf(output_buf, format, args);
 	va_end(args);

-#ifdef ZEND_WIN32
+#if WIN32||WINNT
 	OutputDebugString(output_buf);
 #else
-	fprintf(stderr, "%s", output_buf);
+	fprintf(stderr, output_buf);
 #endif
 }


 ZEND_API int _mem_block_check(void *ptr, int silent ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
 {
-	zend_mem_header *p = (zend_mem_header *) ((char *)ptr - sizeof(zend_mem_header) - PLATFORM_PADDING);
+	mem_header *p = (mem_header *) ((char *)ptr - sizeof(mem_header) - PLATFORM_PADDING);
 	int no_cache_notice=0;
 	int valid_beginning=1;
 	int had_problems=0;
@@ -617,7 +450,7 @@ ZEND_API int _mem_block_check(void *ptr, int silent ZEND_FILE_LINE_DC ZEND_FILE_


 	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 *)(((char *) p)+sizeof(mem_header)+p->size+PLATFORM_PADDING+END_ALIGNMENT(p->size))) != MEM_BLOCK_END_MAGIC) {
 		long magic_num = MEM_BLOCK_END_MAGIC;
 		char *overflow_ptr, *magic_ptr=(char *) &magic_num;
 		int overflows=0;
@@ -627,7 +460,7 @@ ZEND_API int _mem_block_check(void *ptr, int silent ZEND_FILE_LINE_DC ZEND_FILE_
 			return _mem_block_check(ptr, 0 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
 		}
 		had_problems=1;
-		overflow_ptr = ((char *) p)+sizeof(zend_mem_header)+REAL_SIZE(p->size)+PLATFORM_PADDING;
+		overflow_ptr = ((char *) p)+sizeof(mem_header)+p->size+PLATFORM_PADDING;

 		for (i=0; i<sizeof(long); i++) {
 			if (overflow_ptr[i]!=magic_ptr[i]) {
@@ -637,7 +470,7 @@ ZEND_API int _mem_block_check(void *ptr, int silent ZEND_FILE_LINE_DC ZEND_FILE_

 		zend_debug_alloc_output("%10s\t", "End:");
 		zend_debug_alloc_output("Overflown (magic=0x%0.8lX instead of 0x%0.8lX)\n", 
-				*((long *)(((char *) p) + sizeof(zend_mem_header)+REAL_SIZE(p->size)+PLATFORM_PADDING+END_ALIGNMENT(REAL_SIZE(p->size)))), MEM_BLOCK_END_MAGIC);
+				*((long *)(((char *) p) + sizeof(mem_header)+p->size+PLATFORM_PADDING+END_ALIGNMENT(p->size))), MEM_BLOCK_END_MAGIC);
 		zend_debug_alloc_output("%10s\t","");
 		if (overflows>=sizeof(long)) {
 			zend_debug_alloc_output("At least %d bytes overflown\n", sizeof(long));
@@ -668,7 +501,7 @@ ZEND_API int _mem_block_check(void *ptr, int silent ZEND_FILE_LINE_DC ZEND_FILE_

 ZEND_API void _full_mem_check(int silent ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
 {
-	zend_mem_header *p;
+	mem_header *p;
 	int errors=0;
 	ALS_FETCH();

@@ -679,7 +512,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) + PLATFORM_PADDING), (silent?2:3) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC)) {
+		if (!_mem_block_check((void *)((char *)p + sizeof(mem_header) + PLATFORM_PADDING), (silent?2:3) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC)) {
 			errors++;
 		}
 		p = p->pNext;
@@ -690,9 +523,9 @@ 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_API void _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);
+	mem_header *p = (mem_header *) ((char *)ptr-sizeof(mem_header)-PLATFORM_PADDING);
 	ALS_FETCH();

 #if ZEND_DEBUG
@@ -709,7 +542,6 @@ ZEND_API int _persist_alloc(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
 	/* 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;
 }


@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -18,23 +18,19 @@
 */


-#ifndef ZEND_ALLOC_H
-#define ZEND_ALLOC_H
+#ifndef _ALLOC_H
+#define _ALLOC_H

 #include <stdio.h>

-#ifdef ZTS
-#include "../TSRM/TSRM.h"
-#endif
-
 #include "zend_globals_macros.h"

 #define MEM_BLOCK_START_MAGIC	0x7312F8DCL
-#define MEM_BLOCK_END_MAGIC	0x2A8FCC84L
+#define MEM_BLOCK_END_MAGIC		0x2A8FCC84L
 #define MEM_BLOCK_FREED_MAGIC	0x99954317L
 #define MEM_BLOCK_CACHED_MAGIC	0xFB8277DCL

-typedef struct _zend_mem_header {
+typedef struct _mem_header {
 #if ZEND_DEBUG
 	long magic;
 	char *filename;
@@ -42,16 +38,13 @@ typedef struct _zend_mem_header {
 	int reported;
 	char *orig_filename;
 	uint orig_lineno;
-# ifdef ZTS
-	THREAD_T thread_id;
-# endif
 #endif
-    struct _zend_mem_header *pNext;
-    struct _zend_mem_header *pLast;
+    struct _mem_header *pNext;
+    struct _mem_header *pLast;
 	unsigned int size:30;
 	unsigned int persistent:1;
 	unsigned int cached:1;
-} zend_mem_header;
+} mem_header;

 typedef union _align_test {
 	void *ptr;
@@ -59,30 +52,23 @@ typedef union _align_test {
 	long lng;
 } align_test;

-#define MAX_CACHED_MEMORY	11
-#define MAX_CACHED_ENTRIES	256
-#define PRE_INIT_CACHE_ENTRIES	32
+#define MAX_CACHED_MEMORY   64
+#define MAX_CACHED_ENTRIES	16

-#if (defined (__GNUC__) && __GNUC__ >= 2)
-#define PLATFORM_ALIGNMENT (__alignof__ (align_test))
-#else
 #define PLATFORM_ALIGNMENT (sizeof(align_test))
-#endif
-
-#define PLATFORM_PADDING (((PLATFORM_ALIGNMENT-sizeof(zend_mem_header))%PLATFORM_ALIGNMENT+PLATFORM_ALIGNMENT)%PLATFORM_ALIGNMENT)
-
-
-BEGIN_EXTERN_C()
+#define PLATFORM_PADDING (((PLATFORM_ALIGNMENT-sizeof(mem_header))%PLATFORM_ALIGNMENT+PLATFORM_ALIGNMENT)%PLATFORM_ALIGNMENT)

 ZEND_API char *zend_strndup(const char *s, unsigned int length);

+BEGIN_EXTERN_C()
+
 ZEND_API void *_emalloc(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
 ZEND_API void _efree(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
 ZEND_API void *_ecalloc(size_t nmemb, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
 ZEND_API void *_erealloc(void *ptr, size_t size, int allow_failure ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
 ZEND_API char *_estrdup(const char *s ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
 ZEND_API char *_estrndup(const char *s, unsigned int length ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
-ZEND_API int _persist_alloc(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
+ZEND_API void _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)
@@ -123,7 +109,6 @@ ZEND_API void shutdown_memory_manager(int silent, int clean_cache);
 #if ZEND_DEBUG
 ZEND_API int _mem_block_check(void *ptr, int silent ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
 ZEND_API void _full_mem_check(int silent ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
-void zend_debug_alloc_output(char *format, ...);
 #define mem_block_check(ptr, silent) _mem_block_check(ptr, silent ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
 #define full_mem_check(silent) _full_mem_check(silent ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
 #else
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -21,19 +21,17 @@
 #include "zend.h"
 #include "zend_API.h"
 #include "zend_builtin_functions.h"
+#include "zend_operators.h"
+#include "zend_variables.h"
 #include "zend_constants.h"

-#undef ZEND_TEST_EXCEPTIONS
-
 static ZEND_FUNCTION(zend_version);
 static ZEND_FUNCTION(func_num_args);
 static ZEND_FUNCTION(func_get_arg);
 static ZEND_FUNCTION(func_get_args);
-static ZEND_NAMED_FUNCTION(zend_if_strlen);
+static ZEND_FUNCTION(strlen);
 static ZEND_FUNCTION(strcmp);
-static ZEND_FUNCTION(strncmp);
 static ZEND_FUNCTION(strcasecmp);
-static ZEND_FUNCTION(strncasecmp);
 static ZEND_FUNCTION(each);
 static ZEND_FUNCTION(error_reporting);
 static ZEND_FUNCTION(define);
@@ -41,44 +39,18 @@ static ZEND_FUNCTION(defined);
 static ZEND_FUNCTION(get_class);
 static ZEND_FUNCTION(get_parent_class);
 static ZEND_FUNCTION(method_exists);
-static ZEND_FUNCTION(class_exists);
-static ZEND_FUNCTION(function_exists);
 static ZEND_FUNCTION(leak);
-#ifdef ZEND_TEST_EXCEPTIONS
-static ZEND_FUNCTION(crash);
-#endif
-static ZEND_FUNCTION(get_included_files);
-static ZEND_FUNCTION(is_subclass_of);
-static ZEND_FUNCTION(get_class_vars);
-static ZEND_FUNCTION(get_object_vars);
-static ZEND_FUNCTION(get_class_methods);
-static ZEND_FUNCTION(trigger_error);
-static ZEND_FUNCTION(set_error_handler);
-static ZEND_FUNCTION(restore_error_handler);
-static ZEND_FUNCTION(get_declared_classes);
-static ZEND_FUNCTION(get_defined_functions);
-static ZEND_FUNCTION(get_defined_vars);
-static ZEND_FUNCTION(create_function);
-static ZEND_FUNCTION(get_resource_type);
-#if ZEND_DEBUG
-static ZEND_FUNCTION(zend_test_func);
-#endif

-unsigned char first_arg_force_ref[] = { 1, BYREF_FORCE };
-unsigned char first_arg_allow_ref[] = { 1, BYREF_ALLOW };
-unsigned char second_arg_force_ref[] = { 2, BYREF_NONE, BYREF_FORCE };
-unsigned char second_arg_allow_ref[] = { 2, BYREF_NONE, BYREF_ALLOW };
+extern unsigned char first_arg_force_ref[];

 static zend_function_entry builtin_functions[] = {
 	ZEND_FE(zend_version,		NULL)
 	ZEND_FE(func_num_args,		NULL)
 	ZEND_FE(func_get_arg,		NULL)
 	ZEND_FE(func_get_args,		NULL)
-	{ "strlen", zend_if_strlen, NULL },
+	ZEND_FE(strlen,				NULL)
 	ZEND_FE(strcmp,				NULL)
-	ZEND_FE(strncmp,			NULL)
 	ZEND_FE(strcasecmp,			NULL)
-	ZEND_FE(strncasecmp,		NULL)
 	ZEND_FE(each,				first_arg_force_ref)
 	ZEND_FE(error_reporting,	NULL)
 	ZEND_FE(define,				NULL)
@@ -86,37 +58,14 @@ static zend_function_entry builtin_functions[] = {
 	ZEND_FE(get_class,			NULL)
 	ZEND_FE(get_parent_class,	NULL)
 	ZEND_FE(method_exists,		NULL)
-	ZEND_FE(class_exists,		NULL)
-	ZEND_FE(function_exists,	NULL)
 	ZEND_FE(leak,				NULL)
-#ifdef ZEND_TEST_EXCEPTIONS
-	ZEND_FE(crash,				NULL)
-#endif
-	ZEND_FE(get_included_files,	NULL)
-	ZEND_FALIAS(get_required_files,	get_included_files,		NULL)
-	ZEND_FE(is_subclass_of,		NULL)
-	ZEND_FE(get_class_vars,		NULL)
-	ZEND_FE(get_object_vars,	NULL)
-	ZEND_FE(get_class_methods,	NULL)
-	ZEND_FE(trigger_error,		NULL)
-	ZEND_FALIAS(user_error,		trigger_error,		NULL)
-	ZEND_FE(set_error_handler,		NULL)
-	ZEND_FE(restore_error_handler,	NULL)
-	ZEND_FE(get_declared_classes, NULL)
-	ZEND_FE(get_defined_functions, NULL)
-	ZEND_FE(get_defined_vars,	NULL)
-	ZEND_FE(create_function,	NULL)
-	ZEND_FE(get_resource_type,	NULL)
-#if ZEND_DEBUG
-	ZEND_FE(zend_test_func,		NULL)
-#endif
 	{ NULL, NULL, NULL }
 };


 int zend_startup_builtin_functions()
 {
-	return zend_register_functions(builtin_functions, NULL, MODULE_PERSISTENT);
+	return zend_register_functions(builtin_functions, NULL);
 }


@@ -130,14 +79,12 @@ ZEND_FUNCTION(func_num_args)
 {
 	void **p;
 	int arg_count;
+	ELS_FETCH();

-	p = EG(argument_stack).top_element-1-1;
+	p = EG(argument_stack).top_element-1;
 	arg_count = (ulong) *p;		/* this is the amount of arguments passed to func_num_args(); */
-	p -= 1+arg_count;
-	if (*p) {
-		zend_error(E_ERROR, "func_num_args(): Can't be used as a function parameter");
-	}
-	--p;
+
+	p = EG(argument_stack).top_element-1-arg_count-1;
 	if (p>=EG(argument_stack).elements) {
 		RETURN_LONG((ulong) *p);
 	} else {
@@ -154,28 +101,26 @@ ZEND_FUNCTION(func_get_arg)
 	zval **z_requested_offset;
 	zval *arg;
 	long requested_offset;
+	ELS_FETCH();

-	if (ZEND_NUM_ARGS()!=1 || zend_get_parameters_ex(1, &z_requested_offset)==FAILURE) {
+	if (ARG_COUNT(ht)!=1 || getParametersEx(1, &z_requested_offset)==FAILURE) {
 		RETURN_FALSE;
 	}
 	convert_to_long_ex(z_requested_offset);
 	requested_offset = (*z_requested_offset)->value.lval;

-	p = EG(argument_stack).top_element-1-1;
-	arg_count = (ulong) *p;		/* this is the amount of arguments passed to func_get_arg(); */
-	p -= 1+arg_count;
-	if (*p) {
-		zend_error(E_ERROR, "func_get_arg(): Can't be used as a function parameter");
-	}
-	--p;
+	p = EG(argument_stack).top_element-1;
+	arg_count = (ulong) *p;		/* this is the amount of arguments passed to func_num_args(); */
+
+	p = EG(argument_stack).top_element-1-arg_count-1;
 	if (p<EG(argument_stack).elements) {
 		zend_error(E_WARNING, "func_get_arg():  Called from the global scope - no function context");
 		RETURN_FALSE;
 	}
 	arg_count = (ulong) *p;

-	if (requested_offset>=arg_count) {
-		zend_error(E_WARNING, "func_get_arg():  Argument %d not passed to function", requested_offset);
+	if (requested_offset>arg_count) {
+		zend_error(E_WARNING, "func_get_arg():  Only %d arguments passed to function (argument %d requested)", arg_count, requested_offset);
 		RETURN_FALSE;
 	}

@@ -190,15 +135,12 @@ ZEND_FUNCTION(func_get_args)
 	void **p;
 	int arg_count;
 	int i;
+	ELS_FETCH();

-	p = EG(argument_stack).top_element-1-1;
-	arg_count = (ulong) *p;		/* this is the amount of arguments passed to func_get_args(); */
-	p -= 1+arg_count;
-	if (*p) {
-		zend_error(E_ERROR, "func_get_args(): Can't be used as a function parameter");
-	}
-	--p;
+	p = EG(argument_stack).top_element-1;
+	arg_count = (ulong) *p;		/* this is the amount of arguments passed to func_num_args(); */

+	p = EG(argument_stack).top_element-1-arg_count-1;
 	if (p<EG(argument_stack).elements) {
 		zend_error(E_WARNING, "func_get_args():  Called from the global scope - no function context");
 		RETURN_FALSE;
@@ -210,7 +152,7 @@ ZEND_FUNCTION(func_get_args)
 	for (i=0; i<arg_count; i++) {
 		zval *element;

-		ALLOC_ZVAL(element);
+		element = (zval *) emalloc(sizeof(zval));
 		*element = **((zval **) (p-(arg_count-i)));
 		zval_copy_ctor(element);
 		INIT_PZVAL(element);
@@ -221,12 +163,12 @@ ZEND_FUNCTION(func_get_args)

 /* {{{ proto int strlen(string str)
   Get string length */
-ZEND_NAMED_FUNCTION(zend_if_strlen)
+ZEND_FUNCTION(strlen)
 {
 	zval **str;
 	
-	if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &str) == FAILURE) {
-		ZEND_WRONG_PARAM_COUNT();
+	if (ARG_COUNT(ht) != 1 || getParametersEx(1, &str) == FAILURE) {
+		WRONG_PARAM_COUNT;
 	}
 	convert_to_string_ex(str);
 	RETVAL_LONG((*str)->value.str.len);
@@ -239,28 +181,12 @@ ZEND_FUNCTION(strcmp)
 {
 	zval **s1, **s2;
 	
-	if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &s1, &s2) == FAILURE) {
-		ZEND_WRONG_PARAM_COUNT();
+	if (ARG_COUNT(ht) != 2 || getParametersEx(2, &s1, &s2) == FAILURE) {
+		WRONG_PARAM_COUNT;
 	}
 	convert_to_string_ex(s1);
 	convert_to_string_ex(s2);
-	RETURN_LONG(zend_binary_zval_strcmp(*s1,*s2));
-}
-/* }}} */
-
-/* {{{ proto int strncmp(string str1, string str2, int len)
-   Binary safe string comparison */
-ZEND_FUNCTION(strncmp)
-{
-	zval **s1, **s2, **s3;
-	
-	if (ZEND_NUM_ARGS() != 3 || zend_get_parameters_ex(3, &s1, &s2, &s3) == FAILURE) {
-		ZEND_WRONG_PARAM_COUNT();
-	}
-	convert_to_string_ex(s1);
-	convert_to_string_ex(s2);
-	convert_to_long_ex(s3);
-	RETURN_LONG(zend_binary_zval_strncmp(*s1,*s2,*s3));
+	RETURN_LONG(zend_binary_strcmp(*s1,*s2));
 }
 /* }}} */

@@ -270,28 +196,12 @@ ZEND_FUNCTION(strcasecmp)
 {
 	zval **s1, **s2;
 	
-	if (ZEND_NUM_ARGS()!=2 || zend_get_parameters_ex(2, &s1, &s2) == FAILURE) {
-		ZEND_WRONG_PARAM_COUNT();
+	if (ARG_COUNT(ht)!=2 || getParametersEx(2, &s1, &s2) == FAILURE) {
+		WRONG_PARAM_COUNT;
 	}
 	convert_to_string_ex(s1);
 	convert_to_string_ex(s2);
-	RETURN_LONG(zend_binary_zval_strcasecmp(*s1, *s2));
-}
-/* }}} */
-
-/* {{{ proto int strncasecmp(string str1, string str2, int len)
-   Binary safe string comparison */
-ZEND_FUNCTION(strncasecmp)
-{
-	zval **s1, **s2, **s3;
-	
-	if (ZEND_NUM_ARGS() != 3 || zend_get_parameters_ex(3, &s1, &s2, &s3) == FAILURE) {
-		ZEND_WRONG_PARAM_COUNT();
-	}
-	convert_to_string_ex(s1);
-	convert_to_string_ex(s2);
-	convert_to_long_ex(s3);
-	RETURN_LONG(zend_binary_zval_strncasecmp(*s1,*s2,*s3));
+	RETURN_LONG(zend_binary_strcasecmp(*s1, *s2));
 }
 /* }}} */

@@ -303,8 +213,8 @@ ZEND_FUNCTION(each)
 	zval **inserted_pointer;
 	HashTable *target_hash;
 	
-	if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &array) == FAILURE) {
-		ZEND_WRONG_PARAM_COUNT();
+	if (ARG_COUNT(ht) != 1 || getParametersEx(1, &array) == FAILURE) {
+		WRONG_PARAM_COUNT;
 	}
 	target_hash = HASH_OF(*array);
 	if (!target_hash) {
@@ -319,7 +229,7 @@ ZEND_FUNCTION(each)

 	/* add value elements */
 	if (entry->is_ref) {
-		ALLOC_ZVAL(tmp);
+		tmp = (zval *)emalloc(sizeof(zval));
 		*tmp = *entry;
 		zval_copy_ctor(tmp);
 		tmp->is_ref=0;
@@ -328,7 +238,7 @@ ZEND_FUNCTION(each)
 	}
 	zend_hash_index_update(return_value->value.ht, 1, &entry, sizeof(zval *), NULL);
 	entry->refcount++;
-	zend_hash_update(return_value->value.ht, "value", sizeof("value"), &entry, sizeof(zval *), NULL);
+	zend_hash_update_ptr(return_value->value.ht, "value", sizeof("value"), entry, sizeof(zval *), NULL);
 	entry->refcount++;

 	/* add the key elements */
@@ -349,23 +259,24 @@ ZEND_FUNCTION(error_reporting)
 {
 	zval **arg;
 	int old_error_reporting;
+	ELS_FETCH();

 	old_error_reporting = EG(error_reporting);
-	switch (ZEND_NUM_ARGS()) {
+	switch (ARG_COUNT(ht)) {
 		case 0:
 			break;
 		case 1:
-			if (zend_get_parameters_ex(1,&arg) == FAILURE) {
+			if (getParametersEx(1,&arg) == FAILURE) {
 				RETURN_FALSE;
 			}
 			convert_to_long_ex(arg);
 			EG(error_reporting)=(*arg)->value.lval;
 			break;
 		default:
-			ZEND_WRONG_PARAM_COUNT();
+			WRONG_PARAM_COUNT;
 			break;
 	}
-
+	
 	RETVAL_LONG(old_error_reporting);
 }

@@ -374,16 +285,17 @@ ZEND_FUNCTION(define)
 	zval **var, **val, **non_cs;
 	int case_sensitive;
 	zend_constant c;
+	ELS_FETCH();
 	
-	switch(ZEND_NUM_ARGS()) {
+	switch(ARG_COUNT(ht)) {
 		case 2:
-			if (zend_get_parameters_ex(2, &var, &val)==FAILURE) {
+			if (getParametersEx(2, &var, &val)==FAILURE) {
 				RETURN_FALSE;
 			}
 			case_sensitive = CONST_CS;
 			break;
 		case 3:
-			if (zend_get_parameters_ex(3, &var, &val, &non_cs)==FAILURE) {
+			if (getParametersEx(3, &var, &val, &non_cs)==FAILURE) {
 				RETURN_FALSE;
 			}
 			convert_to_long_ex(non_cs);
@@ -394,17 +306,15 @@ ZEND_FUNCTION(define)
 			}
 			break;
 		default:
-			ZEND_WRONG_PARAM_COUNT();
+			WRONG_PARAM_COUNT;
 			break;
 	}
-
 	switch((*val)->type) {
 		case IS_LONG:
 		case IS_DOUBLE:
 		case IS_STRING:
 		case IS_BOOL:
 		case IS_RESOURCE:
-		case IS_NULL:
 			break;
 		default:
 			zend_error(E_WARNING,"Constants may only evaluate to scalar values");
@@ -415,14 +325,11 @@ ZEND_FUNCTION(define)
 	
 	c.value = **val;
 	zval_copy_ctor(&c.value);
-	c.flags = case_sensitive; /* non persistent */
+	c.flags = case_sensitive | ~CONST_PERSISTENT; /* non persistent */
 	c.name = zend_strndup((*var)->value.str.val, (*var)->value.str.len);
 	c.name_len = (*var)->value.str.len+1;
-	if(zend_register_constant(&c ELS_CC) == SUCCESS) {
-	  RETURN_TRUE;
-	} else {
-	  RETURN_FALSE;
-	}
+	zend_register_constant(&c ELS_CC);
+	RETURN_TRUE;
 }


@@ -431,8 +338,8 @@ ZEND_FUNCTION(defined)
 	zval **var;
 	zval c;
 		
-	if (ZEND_NUM_ARGS()!=1 || zend_get_parameters_ex(1, &var)==FAILURE) {
-		ZEND_WRONG_PARAM_COUNT();
+	if (ARG_COUNT(ht)!=1 || getParametersEx(1, &var)==FAILURE) {
+		WRONG_PARAM_COUNT;
 	}
 	
 	convert_to_string_ex(var);
@@ -445,13 +352,14 @@ ZEND_FUNCTION(defined)
 }

 /* {{{ proto string get_class(object object)
-   Retrieves the class name */
+     Retrieves the class name ...
+*/
 ZEND_FUNCTION(get_class)
 {
 	zval **arg;
 	
-	if (ZEND_NUM_ARGS()!=1 || zend_get_parameters_ex(1, &arg)==FAILURE) {
-		ZEND_WRONG_PARAM_COUNT();
+	if (ARG_COUNT(ht)!=1 || getParametersEx(1, &arg)==FAILURE) {
+		RETURN_FALSE;
 	}
 	if ((*arg)->type != IS_OBJECT) {
 		RETURN_FALSE;
@@ -461,13 +369,14 @@ ZEND_FUNCTION(get_class)
 /* }}} */

 /* {{{ proto string get_parent_class(object object)
-   Retrieves the parent class name */
+     Retrieves the parent class name ...
+*/
 ZEND_FUNCTION(get_parent_class)
 {
 	zval **arg;
 	
-	if (ZEND_NUM_ARGS()!=1 || zend_get_parameters_ex(1, &arg)==FAILURE) {
-		ZEND_WRONG_PARAM_COUNT();
+	if (ARG_COUNT(ht)!=1 || getParametersEx(1, &arg)==FAILURE) {
+		RETURN_FALSE;
 	}
 	if (((*arg)->type != IS_OBJECT) || !(*arg)->value.obj.ce->parent) {
 		RETURN_FALSE;
@@ -476,211 +385,35 @@ ZEND_FUNCTION(get_parent_class)
 }
 /* }}} */

-/* {{{ proto bool is_subclass_of(object object, string class_name)
-   Returns true if the object has this class as one of its parents */
-ZEND_FUNCTION(is_subclass_of)
-{
-	zval **obj, **class_name;
-	char *lcname;
-	zend_class_entry *parent_ce = NULL;
-
-	if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &obj, &class_name)==FAILURE) {
-		ZEND_WRONG_PARAM_COUNT();
-	}
-
-	if ((*obj)->type != IS_OBJECT) {
-		RETURN_FALSE;
-	}
-
-	convert_to_string_ex(class_name);
-	lcname = estrndup((*class_name)->value.str.val, (*class_name)->value.str.len);
-	zend_str_tolower(lcname, (*class_name)->value.str.len);
-
-	for (parent_ce = (*obj)->value.obj.ce->parent; parent_ce != NULL; parent_ce = parent_ce->parent) {
-		if (!strcmp(parent_ce->name, lcname)) {
-			efree(lcname);
-			RETURN_TRUE;
-		}
-	}
-	efree(lcname);
-	RETURN_FALSE;
-}
-/* }}} */
-
-/* {{{ proto array get_class_vars(string class_name)
-   Returns an array of default properties of the class */
-ZEND_FUNCTION(get_class_vars)
-{
-	zval **class_name;
-	char *lcname;
-	zend_class_entry *ce;
-	zval *tmp;
-	CLS_FETCH();
-
-	if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &class_name)==FAILURE) {
-		ZEND_WRONG_PARAM_COUNT();
-	}
-
-	convert_to_string_ex(class_name);
-	lcname = estrndup((*class_name)->value.str.val, (*class_name)->value.str.len);
-	zend_str_tolower(lcname, (*class_name)->value.str.len);
-
-	if (zend_hash_find(CG(class_table), lcname, (*class_name)->value.str.len+1, (void **)&ce)==FAILURE) {
-		efree(lcname);
-		RETURN_FALSE;
-	} else {
-		efree(lcname);
-		array_init(return_value);
-		if (!ce->constants_updated) {
-			zend_hash_apply_with_argument(&ce->default_properties, (int (*)(void *,void *)) zval_update_constant, (void *) 1);
-			ce->constants_updated = 1;
-		}
-		zend_hash_copy(return_value->value.ht, &ce->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
-	}
-}
-/* }}} */
-
-/* {{{ proto array get_object_vars(object obj)
-   Returns an array of object properties */
-ZEND_FUNCTION(get_object_vars)
-{
-	zval **obj;
-	zval *tmp;
-
-	if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &obj) == FAILURE) {
-		ZEND_WRONG_PARAM_COUNT();
-	}
-
-	if ((*obj)->type != IS_OBJECT) {
-		RETURN_FALSE;
-	}
-
-	array_init(return_value);
-	zend_hash_copy(return_value->value.ht, (*obj)->value.obj.properties,
-				   (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
-}
-/* }}} */
-
-/* {{{ proto array get_class_methods(string class_name)
-   Returns an array of class methods' names */
-ZEND_FUNCTION(get_class_methods)
-{
-	zval **class_name;
-	zval *method_name;
-	char *lcname;
-	zend_class_entry *ce;
-	char *string_key;
-	ulong num_key;
-	int key_type;
-	CLS_FETCH();
-
-	if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &class_name)==FAILURE) {
-		ZEND_WRONG_PARAM_COUNT();
-	}
-
-	convert_to_string_ex(class_name);
-	lcname = estrndup((*class_name)->value.str.val, (*class_name)->value.str.len);
-	zend_str_tolower(lcname, (*class_name)->value.str.len);
-
-	if (zend_hash_find(CG(class_table), lcname, (*class_name)->value.str.len+1, (void **)&ce)==FAILURE) {
-		efree(lcname);
-		RETURN_NULL();
-	} else {
-		efree(lcname);
-		array_init(return_value);
-		zend_hash_internal_pointer_reset(&ce->function_table);
-		while ((key_type = zend_hash_get_current_key(&ce->function_table, &string_key, &num_key)) != HASH_KEY_NON_EXISTANT) {
-			if (key_type == HASH_KEY_IS_STRING) {
-				MAKE_STD_ZVAL(method_name);
-				ZVAL_STRING(method_name, string_key, 0);
-				zend_hash_next_index_insert(return_value->value.ht, &method_name, sizeof(zval *), NULL);
-			}
-			zend_hash_move_forward(&ce->function_table);
-		}
-	}
-}
-/* }}} */
-
 /* {{{ proto bool method_exists(object object, string method)
-   Checks if the class method exists */
+     Checks if the class method exists ...
+*/
 ZEND_FUNCTION(method_exists)
 {
-	zval **klass, **method_name;
-	char *lcname;
+	zval **arg1, **arg2;
 	
-	if (ZEND_NUM_ARGS()!=2 || zend_get_parameters_ex(2, &klass, &method_name)==FAILURE) {
-		ZEND_WRONG_PARAM_COUNT();
-	}
-	if ((*klass)->type != IS_OBJECT) {
+	if (ARG_COUNT(ht)!=2 || getParametersEx(2, &arg1, &arg2)==FAILURE) {
 		RETURN_FALSE;
 	}
-	convert_to_string_ex(method_name);
-	lcname = estrndup((*method_name)->value.str.val, (*method_name)->value.str.len);
-	zend_str_tolower(lcname, (*method_name)->value.str.len);
-	if(zend_hash_exists(&(*klass)->value.obj.ce->function_table, lcname, (*method_name)->value.str.len+1)) {
-		efree(lcname);
+	if ((*arg1)->type != IS_OBJECT) {
+		RETURN_FALSE;
+	}
+	convert_to_string_ex(arg2);
+	if(zend_hash_exists(&(*arg1)->value.obj.ce->function_table, (*arg2)->value.str.val, (*arg2)->value.str.len+1)) {
 		RETURN_TRUE;
 	} else {
-		efree(lcname);
 		RETURN_FALSE;
 	}
 }
 /* }}} */

-/* {{{ proto bool class_exists(string classname)
-   Checks if the class exists */
-ZEND_FUNCTION(class_exists)
-{
-	zval **class_name;
-	char *lcname;
-	CLS_FETCH();
-
-	if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &class_name)==FAILURE) {
-		ZEND_WRONG_PARAM_COUNT();
-	}
-	convert_to_string_ex(class_name);
-	lcname = estrndup((*class_name)->value.str.val, (*class_name)->value.str.len);
-	zend_str_tolower(lcname, (*class_name)->value.str.len);
-	if (zend_hash_exists(CG(class_table), lcname, (*class_name)->value.str.len+1)) {
-		efree(lcname);
-		RETURN_TRUE;
-	} else {
-		efree(lcname);
-		RETURN_FALSE;
-	}
-}
-/* }}} */
-
-/* {{{ proto bool function_exists(string function_name) 
-   Checks if the function exists */
-ZEND_FUNCTION(function_exists)
-{
-	zval **function_name;
-	char *lcname;
-	int retval;
-	
-	if (ZEND_NUM_ARGS()!=1 || zend_get_parameters_ex(1, &function_name)==FAILURE) {
-		ZEND_WRONG_PARAM_COUNT();
-	}
-	convert_to_string_ex(function_name);
-	lcname = estrndup((*function_name)->value.str.val, (*function_name)->value.str.len);
-	zend_str_tolower(lcname, (*function_name)->value.str.len);
-
-	retval = zend_hash_exists(EG(function_table), lcname, (*function_name)->value.str.len+1);
-	efree(lcname);
-
-	RETURN_BOOL(retval);
-}
-/* }}} */
-
-
 ZEND_FUNCTION(leak)
 {
 	int leakbytes=3;
 	zval **leak;

-	if (ZEND_NUM_ARGS()>=1) {
-		if (zend_get_parameters_ex(1, &leak)==SUCCESS) {
+	if (ARG_COUNT(ht)>=1) {
+		if (getParametersEx(1, &leak)==SUCCESS) {
 			convert_to_long_ex(leak);
 			leakbytes = (*leak)->value.lval;
 		}
@@ -688,326 +421,3 @@ ZEND_FUNCTION(leak)
 	
 	emalloc(leakbytes);
 }
-
-
-#ifdef ZEND_TEST_EXCEPTIONS
-ZEND_FUNCTION(crash)
-{
-	char *nowhere=NULL;
-
-	memcpy(nowhere, "something", sizeof("something"));
-}
-#endif
-
-
-static int copy_import_use_file(zend_file_handle *fh, zval *array)
-{
-	if (fh->filename) {
-		char *extension_start;
-
-		extension_start = strstr(fh->filename, zend_uv.import_use_extension);
-		if (extension_start) {
-			*extension_start = 0;
-			if (fh->opened_path) {
-				add_assoc_string(array, fh->filename, fh->opened_path, 1);
-			} else {
-				add_assoc_stringl(array, fh->filename, "N/A", sizeof("N/A")-1, 1);
-			}
-			*extension_start = zend_uv.import_use_extension[0];
-		}
-	}
-	return 0;
-}
-
-
-/* {{{ proto array get_included_files(void)
-   Returns an array with the file names that were include_once()'d */
-ZEND_FUNCTION(get_included_files)
-{
-	char *entry;
-	if (ZEND_NUM_ARGS() != 0) {
-		ZEND_WRONG_PARAM_COUNT();
-	}
-
-	array_init(return_value);
-	zend_hash_internal_pointer_reset(&EG(included_files));
-	while(zend_hash_get_current_key(&EG(included_files), &entry,NULL) == HASH_KEY_IS_STRING) {
-		add_next_index_string(return_value,entry,0);
-		zend_hash_move_forward(&EG(included_files));
-	}
-
-	/*	zend_hash_apply_with_argument(&EG(included_files), (apply_func_arg_t) copy_import_use_file, return_value); */
-}
-/* }}} */
-
-
-/* {{{ proto void trigger_error(string messsage [, int error_type])
-   Generates a user-level error/warning/notice message */
-ZEND_FUNCTION(trigger_error)
-{
-	int error_type = E_USER_NOTICE;
-	zval **z_error_type, **z_error_message;
-
-	switch(ZEND_NUM_ARGS()) {
-		case 1:
-			if (zend_get_parameters_ex(1, &z_error_message)==FAILURE) {
-				ZEND_WRONG_PARAM_COUNT();
-			}
-			break;
-		case 2:
-			if (zend_get_parameters_ex(2, &z_error_message, &z_error_type)==FAILURE) {
-				ZEND_WRONG_PARAM_COUNT();
-			}
-			convert_to_long_ex(z_error_type);
-			error_type = (*z_error_type)->value.lval;
-			switch (error_type) {
-				case E_USER_ERROR:
-				case E_USER_WARNING:
-				case E_USER_NOTICE:
-					break;
-				default:
-					zend_error(E_WARNING, "Invalid error type specified");
-					RETURN_FALSE;
-					break;
-			}
-			break;
-		default:
-			ZEND_WRONG_PARAM_COUNT();	
-	}
-	convert_to_string_ex(z_error_message);
-	zend_error(error_type, "%s", (*z_error_message)->value.str.val);
-	RETURN_TRUE;
-}
-/* }}} */
-
-
-/* {{{ proto string set_error_handler(string error_handler)
-   Sets a user-defined error handler function.  Returns the previously defined error handler, or false on error */
-ZEND_FUNCTION(set_error_handler)
-{
-	zval **error_handler;
-	zend_bool had_orig_error_handler=0;
-
-	if (ZEND_NUM_ARGS()!=1 || zend_get_parameters_ex(1, &error_handler)==FAILURE) {
-		ZEND_WRONG_PARAM_COUNT();
-	}
-
-	convert_to_string_ex(error_handler);
-	if (EG(user_error_handler)) {
-		had_orig_error_handler = 1;
-		*return_value = *EG(user_error_handler);
-		zval_copy_ctor(return_value);
-		zend_ptr_stack_push(&EG(user_error_handlers), EG(user_error_handler));
-	}
-	ALLOC_ZVAL(EG(user_error_handler));
-
-	if (Z_STRLEN_PP(error_handler)==0) { /* unset user-defined handler */
-		FREE_ZVAL(EG(user_error_handler));
-		EG(user_error_handler) = NULL;
-		RETURN_TRUE;
-	}
-
-	*EG(user_error_handler) = **error_handler;
-	zval_copy_ctor(EG(user_error_handler));
-
-	if (!had_orig_error_handler) {
-		RETURN_NULL();
-	}
-}
-/* }}} */
-
-
-
-/* {{{ proto void restore_error_handler(void)
-   Restores the previously defined error handler function */
-ZEND_FUNCTION(restore_error_handler)
-{
-	if (EG(user_error_handler)) {
-		zval_ptr_dtor(&EG(user_error_handler));
-	}
-	if (zend_ptr_stack_num_elements(&EG(user_error_handlers))==0) {
-		EG(user_error_handler) = NULL;
-	} else {
-		EG(user_error_handler) = zend_ptr_stack_pop(&EG(user_error_handlers));
-	}
-	RETURN_TRUE;
-}
-
-
-static int copy_class_name(zend_class_entry *ce, int num_args, va_list args, zend_hash_key *hash_key)
-{
-	zval *array = va_arg(args, zval *);
-
-	if (hash_key->nKeyLength==0 || hash_key->arKey[0]!=0) {
-		add_next_index_stringl(array, ce->name, ce->name_length, 1);
-	}
-	return 0;
-}
-
-/* {{{ proto array get_declared_classes(void)
-   Returns an array of all declared classes. */
-ZEND_FUNCTION(get_declared_classes)
-{
-	CLS_FETCH();
-
-	if (ZEND_NUM_ARGS() != 0) {
-		ZEND_WRONG_PARAM_COUNT();
-	}
-
-	array_init(return_value);
-	zend_hash_apply_with_arguments(CG(class_table), (apply_func_args_t)copy_class_name, 1, return_value);
-}
-/* }}} */
-
-static int copy_function_name(zend_function *func, int num_args, va_list args, zend_hash_key *hash_key)
-{
-	zval *internal_ar = va_arg(args, zval *),
-	     *user_ar     = va_arg(args, zval *);
-
-	if (hash_key->nKeyLength == 0 || hash_key->arKey[0] == 0) {
-		return 0;
-	}
-
-	if (func->type == ZEND_INTERNAL_FUNCTION) {
-		add_next_index_stringl(internal_ar, hash_key->arKey, hash_key->nKeyLength, 1);
-	} else if (func->type == ZEND_USER_FUNCTION) {
-		add_next_index_stringl(user_ar, hash_key->arKey, hash_key->nKeyLength, 1);
-	}
-	
-	return 0;
-}
-
-/* {{{ proto array get_defined_functions(void)
-   Returns an array of all defined functions */
-ZEND_FUNCTION(get_defined_functions)
-{
-	zval *internal;
-	zval *user;
-	
-	if (ZEND_NUM_ARGS() != 0) {
-		ZEND_WRONG_PARAM_COUNT();
-	}
-	
-	MAKE_STD_ZVAL(internal);
-	MAKE_STD_ZVAL(user);
-	
-	array_init(internal);
-	array_init(user);
-	array_init(return_value);
-	
-	zend_hash_apply_with_arguments(EG(function_table), (apply_func_args_t)copy_function_name, 2, internal, user);
-	
-	if (zend_hash_add(return_value->value.ht, "internal", sizeof("internal"), (void **)&internal, sizeof(zval *), NULL) == FAILURE) {
-		zend_error(E_WARNING, "Cannot add internal functions to return value from get_defined_functions()");
-		RETURN_FALSE;
-	}
-	
-	if (zend_hash_add(return_value->value.ht, "user", sizeof("user"), (void **)&user, sizeof(zval *), NULL) == FAILURE) {
-		zend_error(E_WARNING, "Cannot add user functions to return value from get_defined_functions()");
-		RETURN_FALSE;
-	}
-}
-/* }}} */
-
-/* {{{ proto array get_defined_vars(void)
-   Returns an associative array of names and values of all currently defined variable names (variables in the current scope) */
-ZEND_FUNCTION(get_defined_vars)
-{	
-	zval *tmp;
-	
-	array_init(return_value);
-	
-    zend_hash_copy(return_value->value.ht, EG(active_symbol_table),
-                   (copy_ctor_func_t)zval_add_ref, &tmp, sizeof(zval *));
-}
-/* }}} */
-
-#define LAMBDA_TEMP_FUNCNAME	"__lambda_func"
-
-/* {{{ proto string create_function(string args, string code)
-   Creates an anonymous function, and returns its name (funny, eh?) */
-ZEND_FUNCTION(create_function)
-{
-	char *eval_code, *function_name;
-	int eval_code_length, function_name_length;
-	zval **z_function_args, **z_function_code;
-	int retval;
-	char *eval_name;
-	CLS_FETCH();
-
-	if (ZEND_NUM_ARGS()!=2 || zend_get_parameters_ex(2, &z_function_args, &z_function_code)==FAILURE) {
-		ZEND_WRONG_PARAM_COUNT();
-	}
-
-	convert_to_string_ex(z_function_args);
-	convert_to_string_ex(z_function_code);
-
-	eval_code_length = sizeof("function " LAMBDA_TEMP_FUNCNAME)
-			+Z_STRLEN_PP(z_function_args)
-			+2	/* for the args parentheses */
-			+2	/* for the curly braces */
-			+Z_STRLEN_PP(z_function_code);
-
-	eval_code = (char *) emalloc(eval_code_length);
-	sprintf(eval_code, "function " LAMBDA_TEMP_FUNCNAME "(%s){%s}", Z_STRVAL_PP(z_function_args), Z_STRVAL_PP(z_function_code));
-
-	eval_name = zend_make_compiled_string_description("runtime-created function");
-	retval = zend_eval_string(eval_code, NULL, eval_name CLS_CC ELS_CC);
-	efree(eval_code);
-	efree(eval_name);
-
-	if (retval==SUCCESS) {
-		zend_function *func;
-
-		if (zend_hash_find(EG(function_table), LAMBDA_TEMP_FUNCNAME, sizeof(LAMBDA_TEMP_FUNCNAME), (void **) &func)==FAILURE) {
-			zend_error(E_ERROR, "Unexpected inconsistency in create_function()");
-			RETURN_FALSE;
-		}
-		function_add_ref(func);
-
-		function_name = (char *) emalloc(sizeof("0lambda_")+MAX_LENGTH_OF_LONG);
-
-		do {
-			sprintf(function_name, "%clambda_%d", 0, ++EG(lambda_count));
-			function_name_length = strlen(function_name+1)+1;
-		} while (zend_hash_add(EG(function_table), function_name, function_name_length+1, func, sizeof(zend_function), NULL)==FAILURE);
-		zend_hash_del(EG(function_table), LAMBDA_TEMP_FUNCNAME, sizeof(LAMBDA_TEMP_FUNCNAME));
-		RETURN_STRINGL(function_name, function_name_length, 0);
-	} else {
-		RETURN_FALSE;
-	}
-}
-/* }}} */
-
-
-#if ZEND_DEBUG
-ZEND_FUNCTION(zend_test_func)
-{
-	zval *arg1, *arg2;
-
-	zend_get_parameters(ht, 2, &arg1, &arg2);
-}
-#endif
-
-
-ZEND_FUNCTION(get_resource_type)
-{
-	char *resource_type;
-	zval **z_resource_type;
-
-	if (ZEND_NUM_ARGS()!=1 || zend_get_parameters_ex(1, &z_resource_type)==FAILURE) {
-		ZEND_WRONG_PARAM_COUNT();
-	}
-
-	if (Z_TYPE_PP(z_resource_type) != IS_RESOURCE) {
-		zend_error(E_WARNING, "Supplied argument is not a valid resource handle");
-		RETURN_FALSE;
-	}
-
-	resource_type = zend_rsrc_list_get_rsrc_type(Z_LVAL_PP(z_resource_type));
-	if (resource_type) {
-		RETURN_STRING(resource_type, 1);
-	} else {
-		RETURN_STRING("Unknown", 1);
-	}
-}
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -18,9 +18,9 @@
 */


-#ifndef ZEND_BUILTIN_FUNCTIONS_H
-#define ZEND_BUILTIN_FUNCTIONS_H
+#ifndef _ZEND_BUILTIN_FUNCTIONS_H
+#define _ZEND_BUILTIN_FUNCTIONS_H

-int zend_startup_builtin_functions(void);
+int zend_startup_builtin_functions();

-#endif /* ZEND_BUILTIN_FUNCTIONS_H */
+#endif /* _ZEND_BUILTIN_FUNCTIONS_H */
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -18,8 +18,8 @@
 */


-#ifndef ZEND_COMPILE_H
-#define ZEND_COMPILE_H
+#ifndef _COMPILE_H
+#define _COMPILE_H

 #include "zend.h"

@@ -27,11 +27,9 @@
 # include <stdarg.h>
 #endif

-#ifdef __cplusplus
-#include <istream.h>
-#endif
-
 #include "zend_llist.h"
+#define YYSTYPE znode
+#include "zend-parser.h"

 #define DEBUG_ZEND 0

@@ -44,7 +42,6 @@
 #define FREE_PNODE(znode)	zval_dtor(&znode->u.constant);
 #define FREE_OP(op, should_free) if (should_free) zval_dtor(&Ts[(op)->u.var].tmp_var);

-#define SET_UNUSED(op)  (op).op_type = IS_UNUSED

 #if SUPPORT_INTERACTIVE
 #define INC_BPC(op_array)	((op_array)->backpatch_count++)
@@ -63,24 +60,25 @@ typedef struct _znode {
 	union {
 		zval constant;

-		zend_uint var;
-		zend_uint opline_num; /*  Needs to be signed */
-		zend_uint fetch_type;
+		int var;
+		int opline_num;
+		int fetch_type;
 		zend_op_array *op_array;
 		struct {
-			zend_uint var;	/* dummy */
-			zend_uint type;
+			int var;	/* dummy */
+			int type;
 		} EA;
 	} u;
 } znode;


 typedef struct _zend_op {
-	zend_uchar opcode;
+	int opcode;
 	znode result;
 	znode op1;
 	znode op2;
 	ulong extended_value;
+	char *filename;
 	uint lineno;
 } zend_op;

@@ -93,22 +91,23 @@ typedef struct _zend_brk_cont_element {


 struct _zend_op_array {
-	zend_uchar type;	/* MUST be the first element of this struct! */
+	int type;	/* MUST be the first element of this struct! */

-	zend_uchar *arg_types;		/* MUST be the second element of this struct! */
+	unsigned char *arg_types;		/* MUST be the second element of this struct! */
 	char *function_name;			/* MUST be the third element of this struct! */

-	zend_uint *refcount;
+	int *refcount;

 	zend_op *opcodes;
-	zend_uint last, size;
+	int last, size;
+
+	int T;

-	zend_uint T;

 	zend_brk_cont_element *brk_cont_array;
-	zend_uint last_brk_cont;
-	zend_uint current_brk_cont;
-	zend_bool uses_globals;
+	int last_brk_cont;
+	int current_brk_cont;
+	unsigned char uses_globals;

 	/* static variables support */
 	HashTable *static_variables;
@@ -118,46 +117,31 @@ struct _zend_op_array {
 	int last_executed_op_number;
 	int backpatch_count;
 #endif
-	zend_bool return_reference;
-	zend_bool done_pass_two;
-
-	char *filename;

 	void *reserved[ZEND_MAX_RESERVED_RESOURCES];
 };


 typedef struct _zend_internal_function {
-	zend_uchar type;	/* MUST be the first element of this struct! */
+	int type;	/* MUST be the first element of this struct! */

-	zend_uchar *arg_types;		/* MUST be the second element of this struct */
+	unsigned char *arg_types;		/* MUST be the second element of this struct */
 	char *function_name;			/* MUST be the third element of this struct */

 	void (*handler)(INTERNAL_FUNCTION_PARAMETERS);
 } zend_internal_function;


-typedef struct _zend_overloaded_function {
-	zend_uchar type;	/* MUST be the first element of this struct! */
-
-	zend_uchar *arg_types;		/* MUST be the second element of this struct */
-	char *function_name;		/* MUST be the third element of this struct */
-
-	zend_uint var;
-} zend_overloaded_function;
-
-
 typedef union _zend_function {
-	zend_uchar type;	/* MUST be the first element of this struct! */
+	int type;	/* MUST be the first element of this struct! */
 	struct {
-		zend_uchar type;  /* never used */
-		zend_uchar *arg_types;
+		int type;  /* never used */
+		unsigned char *arg_types;
 		char *function_name;
 	} common;
 	
 	zend_op_array op_array;
 	zend_internal_function internal_function;
-	zend_overloaded_function overloaded_function;
 } zend_function;


@@ -183,9 +167,8 @@ typedef struct _list_llist_element {


 typedef struct _zend_file_handle {
-	zend_uchar type;
+	int type;
 	char *filename;
-	char *opened_path;
 	union {
 		int fd;
 		FILE *fp;
@@ -193,10 +176,10 @@ typedef struct _zend_file_handle {
 		istream *is;
 #endif
 	} handle;
-	zend_bool free_filename;
 } zend_file_handle;


+#include "zend_globals.h"

 #define IS_CONST	(1<<0)
 #define IS_TMP_VAR	(1<<1)
@@ -206,20 +189,14 @@ typedef struct _zend_file_handle {

 #define EXT_TYPE_UNUSED		(1<<0)

-#include "zend_globals.h"
-
-BEGIN_EXTERN_C()
-
 void init_compiler(CLS_D ELS_DC);
 void shutdown_compiler(CLS_D);

-extern ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type CLS_DC);
+BEGIN_EXTERN_C()
+extern ZEND_API zend_op_array *(*zend_compile_files)(int mark_as_ref CLS_DC, int file_count, ...);

 void zend_activate(CLS_D ELS_DC);
 void zend_deactivate(CLS_D ELS_DC);
-void zend_activate_modules(void);
-void zend_deactivate_modules(void);
-

 int lex_scan(zval *zendlval CLS_DC);
 void startup_scanner(CLS_D);
@@ -227,184 +204,181 @@ 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);
+ZEND_API char *zend_get_compiled_filename();

 #ifdef ZTS
 const char *zend_get_zendtext(CLS_D);
 int zend_get_zendleng(CLS_D);
 #endif

+END_EXTERN_C()

 /* parser-driven code generators */
-void zend_do_binary_op(int op, znode *result, znode *op1, znode *op2 CLS_DC);
-void zend_do_unary_op(int op, znode *result, znode *op1 CLS_DC);
-void zend_do_binary_assign_op(int op, znode *result, znode *op1, znode *op2 CLS_DC);
-void zend_do_assign(znode *result, znode *variable, znode *value CLS_DC);
-void zend_do_assign_ref(znode *result, znode *lvar, znode *rvar CLS_DC);
+void 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 zend_do_indirect_references(znode *result, znode *num_references, znode *variable CLS_DC);
-void zend_do_fetch_global_or_static_variable(znode *varname, znode *static_assignment, int fetch_type CLS_DC);
-void zend_do_fetch_globals(znode *varname CLS_DC);
+void 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 CLS_DC);
 void fetch_array_dim(znode *result, znode *parent, znode *dim CLS_DC);
-void fetch_string_offset(znode *result, znode *parent, znode *offset CLS_DC);
-void zend_do_print(znode *result, znode *arg CLS_DC);
-void zend_do_echo(znode *arg CLS_DC);
+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 CLS_DC);
-void zend_do_while_end(znode *while_token, znode *close_bracket_token CLS_DC);
-void zend_do_do_while_begin(CLS_D);
-void zend_do_do_while_end(znode *do_token, znode *expr_open_bracket, znode *expr CLS_DC);
+void 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 CLS_DC);


-void zend_do_if_cond(znode *cond, znode *closing_bracket_token CLS_DC);
-void zend_do_if_after_statement(znode *closing_bracket_token, unsigned char initialize CLS_DC);
-void zend_do_if_end(CLS_D);
+void 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 CLS_DC);
-void zend_do_for_before_statement(znode *cond_start, znode *second_semicolon_token CLS_DC);
-void zend_do_for_end(znode *second_semicolon_token CLS_DC);
+void 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, int op CLS_DC);
-void zend_do_post_incdec(znode *result, znode *op1, int op CLS_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(CLS_D);
-void zend_do_end_variable_parse(int type, int arg_offset CLS_DC);
+void do_begin_variable_parse(CLS_D);
+void do_end_variable_parse(int type, int arg_offset CLS_DC);

-void zend_do_free(znode *op1 CLS_DC);
+void do_free(znode *op1 CLS_DC);

-void zend_do_init_string(znode *result CLS_DC);
-void zend_do_add_char(znode *result, znode *op1, znode *op2 CLS_DC);
-void zend_do_add_string(znode *result, znode *op1, znode *op2 CLS_DC);
-void zend_do_add_variable(znode *result, znode *op1, znode *op2 CLS_DC);
+void 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_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference CLS_DC);
-void zend_do_end_function_declaration(znode *function_token CLS_DC);
-void zend_do_receive_arg(int op, znode *var, znode *offset, znode *initialization, unsigned char pass_type CLS_DC);
-int zend_do_begin_function_call(znode *function_name CLS_DC);
-void zend_do_begin_dynamic_function_call(znode *function_name CLS_DC);
-void zend_do_begin_class_member_function_call(znode *class_name, znode *function_name CLS_DC);
-void zend_do_end_function_call(znode *function_name, znode *result, znode *argument_list, int is_method, int is_dynamic_fcall CLS_DC);
-void zend_do_return(znode *expr, int do_end_vparse CLS_DC);
+void do_begin_function_declaration(znode *function_token, znode *function_name, int is_method 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 CLS_DC);
 ZEND_API int do_bind_function_or_class(zend_op *opline, HashTable *function_table, HashTable *class_table, int compile_time);
-void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent_ce);
-void zend_do_early_binding(CLS_D);
+void do_early_binding(CLS_D);

-void zend_do_pass_param(znode *param, int op, int offset CLS_DC);
+void do_pass_param(znode *param, int op, int offset CLS_DC);


-void zend_do_boolean_or_begin(znode *expr1, znode *op_token CLS_DC);
-void zend_do_boolean_or_end(znode *result, znode *expr1, znode *expr2, znode *op_token CLS_DC);
-void zend_do_boolean_and_begin(znode *expr1, znode *op_token CLS_DC);               
-void zend_do_boolean_and_end(znode *result, znode *expr1, znode *expr2, znode *op_token CLS_DC);
+void 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(int op, znode *expr CLS_DC);
+void do_brk_cont(int op, znode *expr CLS_DC);

-void zend_do_switch_cond(znode *cond CLS_DC);
-void zend_do_switch_end(znode *case_list CLS_DC);
-void zend_do_case_before_statement(znode *case_list, znode *case_token, znode *case_expr CLS_DC);
-void zend_do_case_after_statement(znode *result, znode *case_token CLS_DC);
-void zend_do_default_before_statement(znode *case_list, znode *default_token CLS_DC);
+void 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_name, znode *parent_class_name CLS_DC);
-void zend_do_end_class_declaration(CLS_D);
-void zend_do_declare_property(znode *var_name, znode *value CLS_DC);
+void 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 CLS_DC);
+void do_fetch_property(znode *result, znode *object, znode *property CLS_DC);


-void zend_do_push_object(znode *object CLS_DC);
-void zend_do_pop_object(znode *object CLS_DC);
+void 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_name CLS_DC);
-void zend_do_end_new_object(znode *result, znode *class_name, znode *new_token, znode *argument_list CLS_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_name, int mode CLS_DC);
+void do_fetch_constant(znode *result, znode *constant_name, int mode CLS_DC);

-void zend_do_shell_exec(znode *result, znode *cmd CLS_DC);
+void do_shell_exec(znode *result, znode *cmd CLS_DC);

-void zend_do_init_array(znode *result, znode *expr, znode *offset, int is_ref CLS_DC);
-void zend_do_add_array_element(znode *result, znode *expr, znode *offset, int is_ref CLS_DC);
-void zend_do_add_static_array_element(znode *result, znode *offset, znode *expr);
-void zend_do_list_init(CLS_D);
-void zend_do_list_end(znode *result, znode *expr CLS_DC);
-void zend_do_add_list_element(znode *element CLS_DC);
-void zend_do_new_list_begin(CLS_D);
-void zend_do_new_list_end(CLS_D);
+void 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();
+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 CLS_DC);
-void zend_do_include_or_eval(int type, znode *result, znode *op1 CLS_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 CLS_DC);
-void zend_do_isset_or_isempty(int type, znode *result, znode *variable CLS_DC);
+void do_unset(znode *variable CLS_DC);
+void do_isset_or_isempty(int type, znode *result, znode *variable CLS_DC);

-void zend_do_foreach_begin(znode *foreach_token, znode *array, znode *open_brackets_token, znode *as_token, int variable CLS_DC);
-void zend_do_foreach_cont(znode *value, znode *key, znode *as_token CLS_DC);
-void zend_do_foreach_end(znode *foreach_token, znode *open_brackets_token CLS_DC);
+void do_foreach_begin(znode *foreach_token, znode *array, znode *open_brackets_token, znode *as_token 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_declare_begin(CLS_D);
-void zend_do_declare_stmt(znode *var, znode *val CLS_DC);
-void zend_do_declare_end(CLS_D);
+void do_end_heredoc(CLS_D);

-void zend_do_end_heredoc(CLS_D);
+void do_exit(znode *result, znode *message CLS_DC);

-void zend_do_exit(znode *result, znode *message CLS_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 CLS_DC);
-void zend_do_end_silence(znode *strudel_token CLS_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 CLS_DC);
-void zend_do_qm_true(znode *true_value, znode *qm_token, znode *colon_token CLS_DC);
-void zend_do_qm_false(znode *result, znode *false_value, znode *qm_token, znode *colon_token CLS_DC);
-
-void zend_do_extended_info(CLS_D);
-void zend_do_extended_fcall_begin(CLS_D);
-void zend_do_extended_fcall_end(CLS_D);
-
-void zend_do_ticks(CLS_D);
-
-ZEND_API void function_add_ref(zend_function *function);
+void do_extended_info(CLS_D);
+void do_extended_fcall_begin(CLS_D);
+void do_extended_fcall_end(CLS_D);

 #define INITIAL_OP_ARRAY_SIZE 64


-/* helper functions in zend_language_scanner.l */
-ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type CLS_DC);
-ZEND_API zend_op_array *compile_string(zval *source_string, char *filename CLS_DC);	
-ZEND_API zend_op_array *compile_filename(int type, zval *filename CLS_DC ELS_DC);
-ZEND_API int zend_execute_scripts(int type CLS_DC ELS_DC, int file_count, ...);
+/* helper functions in zend-scanner.l */
+BEGIN_EXTERN_C()
+ZEND_API int require_file(zend_file_handle *file_handle CLS_DC);	
+ZEND_API int require_filename(char *filename CLS_DC);				
+ZEND_API zend_op_array *compile_files(int mark_as_ref CLS_DC, int file_count, ...);
+ZEND_API zend_op_array *v_compile_files(int mark_as_ref CLS_DC, int file_count, va_list files);
+ZEND_API zend_op_array *compile_string(zval *source_string CLS_DC);	
+ZEND_API zend_op_array *compile_filename(zval *filename CLS_DC);
 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 init_op_array(zend_op_array *op_array, int initial_ops_size);
 ZEND_API void destroy_op_array(zend_op_array *op_array);
-ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle CLS_DC);
-ZEND_API void zend_file_handle_dtor(zend_file_handle *fh);
+ZEND_API void zend_close_file_handle(zend_file_handle *file_handle CLS_DC);
+ZEND_API void zend_open_file_dtor(void *f);
+END_EXTERN_C()

-ZEND_API void destroy_zend_function(zend_function *function);
-ZEND_API void destroy_zend_class(zend_class_entry *ce);
+ZEND_API int destroy_zend_function(zend_function *function);
+ZEND_API int destroy_zend_class(zend_class_entry *ce);
 void zend_class_add_ref(zend_class_entry *ce);

-#define ZEND_FUNCTION_DTOR (void (*)(void *)) destroy_zend_function
-#define ZEND_CLASS_DTOR (void (*)(void *)) destroy_zend_class
+#define ZEND_FUNCTION_DTOR (int (*)(void *)) destroy_zend_function
+#define ZEND_CLASS_DTOR (int (*)(void *)) destroy_zend_class

 zend_op *get_next_op(zend_op_array *op_array CLS_DC);
 void init_op(zend_op *op CLS_DC);
 int get_next_op_number(zend_op_array *op_array);
 int print_class(zend_class_entry *class_entry);
 void print_op_array(zend_op_array *op_array, int optimizations);
+BEGIN_EXTERN_C()
 int pass_two(zend_op_array *op_array);
+void pass_include_eval(zend_op_array *op_array);
+END_EXTERN_C()
 zend_brk_cont_element *get_next_brk_cont_element(zend_op_array *op_array);
-ZEND_API zend_bool zend_is_compiling(void);
-ZEND_API char *zend_make_compiled_string_description(char *name);
+

 int zendlex(znode *zendlval CLS_DC);

+
 #define ZEND_NOP					0
 									
 #define ZEND_ADD					1
@@ -422,123 +396,115 @@ int zendlex(znode *zendlval CLS_DC);
 #define ZEND_BOOL_NOT				13
 #define ZEND_BOOL_XOR				14
 #define ZEND_IS_IDENTICAL			15
-#define ZEND_IS_NOT_IDENTICAL       16
-#define ZEND_IS_EQUAL				17
-#define ZEND_IS_NOT_EQUAL			18
-#define ZEND_IS_SMALLER				19
-#define ZEND_IS_SMALLER_OR_EQUAL	20
-#define ZEND_CAST					21
-#define ZEND_QM_ASSIGN				22
+#define ZEND_IS_EQUAL				16
+#define ZEND_IS_NOT_EQUAL			17
+#define ZEND_IS_SMALLER				18
+#define ZEND_IS_SMALLER_OR_EQUAL	19
+#define ZEND_CAST					20
+#define ZEND_QM_ASSIGN				21

-#define ZEND_ASSIGN_ADD				23
-#define ZEND_ASSIGN_SUB				24
-#define ZEND_ASSIGN_MUL				25
-#define ZEND_ASSIGN_DIV				26
-#define ZEND_ASSIGN_MOD				27
-#define ZEND_ASSIGN_SL				28
-#define ZEND_ASSIGN_SR				29
-#define ZEND_ASSIGN_CONCAT			30
-#define ZEND_ASSIGN_BW_OR			31
-#define ZEND_ASSIGN_BW_AND			32
-#define ZEND_ASSIGN_BW_XOR			33
+#define ZEND_ASSIGN_ADD				22
+#define ZEND_ASSIGN_SUB				23
+#define ZEND_ASSIGN_MUL				24
+#define ZEND_ASSIGN_DIV				25
+#define ZEND_ASSIGN_MOD				26
+#define ZEND_ASSIGN_SL				27
+#define ZEND_ASSIGN_SR				28
+#define ZEND_ASSIGN_CONCAT			29
+#define ZEND_ASSIGN_BW_OR			30
+#define ZEND_ASSIGN_BW_AND			31
+#define ZEND_ASSIGN_BW_XOR			32
 									
-#define ZEND_PRE_INC				34
-#define ZEND_PRE_DEC				35
-#define ZEND_POST_INC				36
-#define ZEND_POST_DEC				37
-								 	
-#define ZEND_ASSIGN					38
-#define ZEND_ASSIGN_REF				39
-
-#define ZEND_ECHO					40
-#define ZEND_PRINT					41
-
-#define ZEND_JMP					42
-#define ZEND_JMPZ					43
-#define ZEND_JMPNZ					44
-#define ZEND_JMPZNZ					45
-#define ZEND_JMPZ_EX				46
-#define ZEND_JMPNZ_EX				47
-#define ZEND_CASE					48
-#define ZEND_SWITCH_FREE			49
-#define ZEND_BRK					50
-#define ZEND_CONT					51
-#define ZEND_BOOL					52
-
-#define ZEND_INIT_STRING			53
-#define ZEND_ADD_CHAR				54
-#define ZEND_ADD_STRING				55
-#define ZEND_ADD_VAR				56
-
-#define ZEND_BEGIN_SILENCE			57
-#define ZEND_END_SILENCE			58
-
-#define ZEND_INIT_FCALL_BY_NAME		59
-#define ZEND_DO_FCALL				60
-#define ZEND_DO_FCALL_BY_NAME		61
-#define ZEND_RETURN					62
-
-#define ZEND_RECV					63
-#define ZEND_RECV_INIT				64
+#define ZEND_PRE_INC				33
+#define ZEND_PRE_DEC				34
+#define ZEND_POST_INC				35
+#define ZEND_POST_DEC				36
 									
-#define ZEND_SEND_VAL				65
-#define ZEND_SEND_VAR				66
-#define ZEND_SEND_REF				67
+#define ZEND_ASSIGN					37
+#define ZEND_ASSIGN_REF				38

-#define ZEND_NEW 					68
-#define ZEND_JMP_NO_CTOR			69
-#define ZEND_FREE					70
+#define ZEND_ECHO					39
+#define ZEND_PRINT					40
+
+#define ZEND_JMP					41
+#define ZEND_JMPZ					42
+#define ZEND_JMPNZ					43
+#define ZEND_JMPZNZ					44
+#define ZEND_JMPZ_EX				45
+#define ZEND_JMPNZ_EX				46
+#define ZEND_CASE					47
+#define ZEND_SWITCH_FREE			48
+#define ZEND_BRK					49
+#define ZEND_CONT					50
+#define ZEND_BOOL					51
+
+#define ZEND_INIT_STRING			52
+#define ZEND_ADD_CHAR				53
+#define ZEND_ADD_STRING				54
+#define ZEND_ADD_VAR				55
+
+#define ZEND_BEGIN_SILENCE			56
+#define ZEND_END_SILENCE			57
+
+#define ZEND_INIT_FCALL_BY_NAME		58
+#define ZEND_DO_FCALL				59
+#define ZEND_DO_FCALL_BY_NAME		60
+#define ZEND_RETURN					61
+
+#define ZEND_RECV					62
+#define ZEND_RECV_INIT				63
 									
-#define ZEND_INIT_ARRAY				71
-#define ZEND_ADD_ARRAY_ELEMENT		72
+#define ZEND_SEND_VAL				64
+#define ZEND_SEND_VAR				65
+#define ZEND_SEND_REF				66
+
+#define ZEND_NEW 					67
+#define ZEND_JMP_NO_CTOR			68
+#define ZEND_FREE					69
 									
-#define ZEND_INCLUDE_OR_EVAL		73
+#define ZEND_INIT_ARRAY				70
+#define ZEND_ADD_ARRAY_ELEMENT		71
 									
-#define ZEND_UNSET_VAR				74
-#define ZEND_UNSET_DIM_OBJ			75
-#define ZEND_ISSET_ISEMPTY			76
+#define ZEND_INCLUDE_OR_EVAL		72
 									
-#define ZEND_FE_RESET				77
-#define ZEND_FE_FETCH				78
+#define ZEND_UNSET_VAR				73
+#define ZEND_UNSET_DIM_OBJ			74
+#define ZEND_ISSET_ISEMPTY			75
 									
-#define ZEND_EXIT					79
+#define ZEND_FE_RESET				76
+#define ZEND_FE_FETCH				77
+									
+#define ZEND_EXIT					78


-/* the following 18 opcodes are 6 groups of 3 opcodes each, and must
+/* the following 15 opcodes are 5 groups of 3 opcodes each, and must
 * remain in that order!
 */
-#define ZEND_FETCH_R				80
-#define ZEND_FETCH_DIM_R			81
-#define ZEND_FETCH_OBJ_R			82
-#define ZEND_FETCH_W				83
-#define ZEND_FETCH_DIM_W			84
-#define ZEND_FETCH_OBJ_W			85
-#define ZEND_FETCH_RW				86
-#define ZEND_FETCH_DIM_RW			87
-#define ZEND_FETCH_OBJ_RW			88
-#define ZEND_FETCH_IS				89
-#define ZEND_FETCH_DIM_IS			90
-#define ZEND_FETCH_OBJ_IS			91
-#define ZEND_FETCH_FUNC_ARG			92
-#define ZEND_FETCH_DIM_FUNC_ARG		93
-#define ZEND_FETCH_OBJ_FUNC_ARG		94
-#define ZEND_FETCH_UNSET			95
-#define ZEND_FETCH_DIM_UNSET		96
-#define ZEND_FETCH_OBJ_UNSET		97
+#define ZEND_FETCH_R				79
+#define ZEND_FETCH_DIM_R			80
+#define ZEND_FETCH_OBJ_R			81
+#define ZEND_FETCH_W				82
+#define ZEND_FETCH_DIM_W			83
+#define ZEND_FETCH_OBJ_W			84
+#define ZEND_FETCH_RW				85
+#define ZEND_FETCH_DIM_RW			86
+#define ZEND_FETCH_OBJ_RW			87
+#define ZEND_FETCH_IS				88
+#define ZEND_FETCH_DIM_IS			89
+#define ZEND_FETCH_OBJ_IS			90
+#define ZEND_FETCH_FUNC_ARG			91
+#define ZEND_FETCH_DIM_FUNC_ARG		92
+#define ZEND_FETCH_OBJ_FUNC_ARG		93

-#define ZEND_FETCH_DIM_TMP_VAR		98
-#define ZEND_FETCH_CONSTANT			99
+#define ZEND_FETCH_DIM_TMP_VAR		94
+#define ZEND_FETCH_CONSTANT			95

-#define ZEND_DECLARE_FUNCTION_OR_CLASS	100
+#define ZEND_DECLARE_FUNCTION_OR_CLASS	96

-#define ZEND_EXT_STMT				101
-#define ZEND_EXT_FCALL_BEGIN		102
-#define ZEND_EXT_FCALL_END			103
-#define ZEND_EXT_NOP				104
-
-#define ZEND_TICKS					105
-
-#define ZEND_SEND_VAR_NO_REF		106
+#define ZEND_EXT_STMT				97
+#define ZEND_EXT_FCALL_BEGIN		98
+#define ZEND_EXT_FCALL_END			99
+#define ZEND_EXT_NOP				100

 /* end of block */

@@ -557,7 +523,6 @@ int zendlex(znode *zendlval CLS_DC);
 #define BP_VAR_IS			3
 #define BP_VAR_NA			4	/* if not applicable */
 #define BP_VAR_FUNC_ARG		5
-#define BP_VAR_UNSET		6


 #define ZEND_INTERNAL_FUNCTION		1
@@ -570,9 +535,6 @@ int zendlex(znode *zendlval CLS_DC);

 #define ZEND_EVAL				(1<<0)
 #define ZEND_INCLUDE			(1<<1)
-#define ZEND_INCLUDE_ONCE		(1<<2)
-#define ZEND_REQUIRE			(1<<3)
-#define ZEND_REQUIRE_ONCE		(1<<4)

 #define ZEND_ISSET				(1<<0)
 #define ZEND_ISEMPTY			(1<<1)
@@ -581,11 +543,10 @@ int zendlex(znode *zendlval CLS_DC);
 #define ZEND_RT (1<<1)


-#define ZEND_HANDLE_FILENAME		0
-#define ZEND_HANDLE_FD				1
-#define ZEND_HANDLE_FP				2
-#define ZEND_HANDLE_STDIOSTREAM		3
-#define ZEND_HANDLE_FSTREAM			4
+#define ZEND_HANDLE_FILENAME	0
+#define ZEND_HANDLE_FD			1
+#define ZEND_HANDLE_FP			2
+#define ZEND_HANDLE_ISTREAM		3

 #define ZEND_DECLARE_CLASS				1
 #define ZEND_DECLARE_FUNCTION			2
@@ -597,8 +558,6 @@ int zendlex(znode *zendlval CLS_DC);
 #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) { \
@@ -608,6 +567,27 @@ int zendlex(znode *zendlval CLS_DC);
 		(ai).ptr = NULL; \
 	}

+#define PZVAL_IS_REF(z)		((z)->is_ref)
+
+#define PZVAL_LOCK(z)	((z)->refcount++)
+#define PZVAL_UNLOCK(z)	{ ((z)->refcount--);							\
+							if (!(z)->refcount) {						\
+								EG(garbage)[EG(garbage_ptr)++] = (z);	\
+								if (EG(garbage_ptr) == 4) {				\
+									zval_dtor(EG(garbage)[0]);			\
+									efree(EG(garbage)[0]);				\
+									zval_dtor(EG(garbage)[1]);			\
+									efree(EG(garbage)[1]);				\
+									EG(garbage)[0] = EG(garbage)[2];	\
+									EG(garbage)[1] = EG(garbage)[3];	\
+									EG(garbage_ptr) -= 2;				\
+								}										\
+							}											\
+						}
+
+#define SELECTIVE_PZVAL_LOCK(pzv, pzn)		if (!((pzn)->u.EA.type & EXT_TYPE_UNUSED)) { PZVAL_LOCK(pzv); }
+
+
 /* Lost In Stupid Parentheses */
 #define ARG_SHOULD_BE_SENT_BY_REF(offset, conduct_check, arg_types)	\
 	(																\
@@ -626,9 +606,4 @@ int zendlex(znode *zendlval CLS_DC);
 		)															\
 	)

-#define ZEND_RETURN_VAL 0
-#define ZEND_RETURN_REF 1
-
-END_EXTERN_C()
-
-#endif /* ZEND_COMPILE_H */
+#endif /* _COMPILE_H */
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -18,13 +18,12 @@
 */


-#ifndef ZEND_CONFIG_W32_H
-#define ZEND_CONFIG_W32_H
+#ifndef _ZEND_CONFIG_W32_H
+#define _ZEND_CONFIG_W32_H


 #include <string.h>
 #include <windows.h>
-#include <float.h>

 typedef unsigned long ulong;
 typedef unsigned int uint;
@@ -42,27 +41,22 @@ typedef unsigned int uint;
 #define HAVE_STDIOSTR_H 1
 #define HAVE_CLASS_ISTDIOSTREAM
 #define istdiostream stdiostream
-#define HAVE_STDARG_H	1
-#define HAVE_SNPRINTF	1
-#define HAVE_VSNPRINTF	1

-#define vsnprintf _vsnprintf
-#define zend_isinf(a)	0
+#ifdef inline
+#undef inline
+#endif

 #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
+/* Visual C++ doesn't really work with inline for C */
+#define inline

-#define zend_finite(A) _finite(A)
-#define zend_isnan(A) _isnan(A)
+
+#define DL_LOAD(libname)	LoadLibrary(libname)
+#define DL_FETCH_SYMBOL		GetProcAddress
+#define DL_UNLOAD			FreeLibrary
+#define DL_HANDLE			HMODULE
+#define ZEND_EXTENSIONS_SUPPORT 1

 #ifdef LIBZEND_EXPORTS
 #	define ZEND_API __declspec(dllexport)
@@ -70,17 +64,4 @@ typedef unsigned int uint;
 #	define ZEND_API __declspec(dllimport)
 #endif

-#define ZEND_DLEXPORT		__declspec(dllexport)
-
-/* 0x00200000L is MB_SERVICE_NOTIFICATION, which is only supported under Windows NT 
- * (and requires _WIN32_WINNT to be defined, which prevents the resulting executable
- * from running under Windows 9x
- * Windows 9x should silently ignore it, so it's being used here directly
- */
-#ifndef MB_SERVICE_NOTIFICATION
-#define	MB_SERVICE_NOTIFICATION		0x00200000L
-#endif
-
-#define ZEND_SERVICE_MB_STYLE		(MB_TOPMOST|MB_SERVICE_NOTIFICATION)
-
-#endif /* ZEND_CONFIG_W32_H */
+#endif /* _ZEND_CONFIG_W32_H */
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -25,21 +25,20 @@
 #include "zend_globals.h"


-void free_zend_constant(zend_constant *c)
+int free_zend_constant(zend_constant *c)
 {
 	if (!(c->flags & CONST_PERSISTENT)) {
 		zval_dtor(&c->value);
 	}
 	free(c->name);
+	return 1;
 }


 void copy_zend_constant(zend_constant *c)
 {
 	c->name = zend_strndup(c->name, c->name_len);
-	if (!(c->flags & CONST_PERSISTENT)) {
-		zval_copy_ctor(&c->value);
-	}
+	zval_copy_ctor(&c->value);
 }


@@ -47,7 +46,7 @@ void zend_copy_constants(HashTable *target, HashTable *source)
 {
 	zend_constant tmp_constant;

-	zend_hash_copy(target, source, (copy_ctor_func_t) copy_zend_constant, &tmp_constant, sizeof(zend_constant));
+	zend_hash_copy(target, source, (void (*)(void *)) copy_zend_constant, &tmp_constant, sizeof(zend_constant));
 }


@@ -81,7 +80,7 @@ void clean_module_constants(int module_number)

 int zend_startup_constants(ELS_D)
 {
-#ifdef ZEND_WIN32
+#if WIN32|WINNT
 	DWORD dwBuild=0;
 	DWORD dwVersion = GetVersion();
 	DWORD dwWindowsMajorVersion =  (DWORD)(LOBYTE(LOWORD(dwVersion)));
@@ -100,6 +99,26 @@ int zend_startup_constants(ELS_D)

 void zend_register_standard_constants(ELS_D)
 {
+	/* ZEND_FIX:  Move to PHP */
+#if 0
+#if WIN32|WINNT
+	/* Get build numbers for Windows NT or Win95 */
+	if (dwVersion < 0x80000000){
+		php3_os="WINNT";
+	} else {
+		php3_os="WIN32";
+	}
+#else
+	php3_os=PHP_OS;
+#endif
+#endif
+
+
+#if 0
+	/* This should go back to PHP */
+	REGISTER_MAIN_STRINGL_CONSTANT("PHP_VERSION", PHP_VERSION, sizeof(PHP_VERSION)-1, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_STRINGL_CONSTANT("PHP_OS", php3_os, strlen(php3_os), CONST_PERSISTENT | CONST_CS);
+#endif
 	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);
@@ -108,9 +127,6 @@ void zend_register_standard_constants(ELS_D)
 	REGISTER_MAIN_LONG_CONSTANT("E_CORE_WARNING", E_CORE_WARNING, CONST_PERSISTENT | CONST_CS);
 	REGISTER_MAIN_LONG_CONSTANT("E_COMPILE_ERROR", E_COMPILE_ERROR, CONST_PERSISTENT | CONST_CS);
 	REGISTER_MAIN_LONG_CONSTANT("E_COMPILE_WARNING", E_COMPILE_WARNING, CONST_PERSISTENT | CONST_CS);
-	REGISTER_MAIN_LONG_CONSTANT("E_USER_ERROR", E_USER_ERROR, CONST_PERSISTENT | CONST_CS);
-	REGISTER_MAIN_LONG_CONSTANT("E_USER_WARNING", E_USER_WARNING, CONST_PERSISTENT | CONST_CS);
-	REGISTER_MAIN_LONG_CONSTANT("E_USER_NOTICE", E_USER_NOTICE, CONST_PERSISTENT | CONST_CS);

 	REGISTER_MAIN_LONG_CONSTANT("E_ALL", E_ALL, CONST_PERSISTENT | CONST_CS);

@@ -122,28 +138,17 @@ void zend_register_standard_constants(ELS_D)
 		c.flags = CONST_PERSISTENT;
 		c.module_number = 0;

-		c.name = zend_strndup(ZEND_STRL("TRUE"));
-		c.name_len = sizeof("TRUE");
+		c.name = zend_strndup("TRUE",4);
+		c.name_len = 5;
 		c.value.value.lval = 1;
 		c.value.type = IS_BOOL;
 		zend_register_constant(&c ELS_CC);
 		
-		c.name = zend_strndup(ZEND_STRL("FALSE"));
-		c.name_len = sizeof("FALSE");
+		c.name = zend_strndup("FALSE",5);
+		c.name_len = 6;
 		c.value.value.lval = 0;
 		c.value.type = IS_BOOL;
 		zend_register_constant(&c ELS_CC);
-
-		c.name = zend_strndup(ZEND_STRL("ZEND_THREAD_SAFE"));
-		c.name_len = sizeof("ZEND_THREAD_SAFE");
-		c.value.value.lval = ZTS_V;
-		c.value.type = IS_BOOL;
-		zend_register_constant(&c ELS_CC);
-
-		c.name = zend_strndup(ZEND_STRL("NULL"));
-		c.name_len = sizeof("NULL");
-		c.value.type = IS_NULL;
-		zend_register_constant(&c ELS_CC);
 	}
 }

@@ -239,10 +244,9 @@ ZEND_API int zend_get_constant(char *name, uint name_len, zval *result)
 }


-ZEND_API int zend_register_constant(zend_constant *c ELS_DC)
+ZEND_API void zend_register_constant(zend_constant *c ELS_DC)
 {
 	char *lowercase_name = zend_strndup(c->name, c->name_len);
-	int ret = SUCCESS;

 #if 0
 	printf("Registering constant for module %d\n",c->module_number);
@@ -251,11 +255,8 @@ ZEND_API int zend_register_constant(zend_constant *c ELS_DC)
 	zend_str_tolower(lowercase_name, c->name_len);
 	if (zend_hash_add(EG(zend_constants), lowercase_name, c->name_len, (void *) c, sizeof(zend_constant), NULL)==FAILURE) {
 		zval_dtor(&c->value);
-		zend_error(E_NOTICE,"Constant %s already defined",lowercase_name);
-		ret = FAILURE;
 	}
 	free(lowercase_name);
-	return ret;
 }


@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -18,8 +18,8 @@
 */


-#ifndef ZEND_CONSTANTS_H
-#define ZEND_CONSTANTS_H
+#ifndef _CONSTANTS_H
+#define _CONSTANTS_H

 #include "zend_globals.h"

@@ -45,7 +45,7 @@ typedef struct _zend_constant {
 #define REGISTER_MAIN_STRINGL_CONSTANT(name,str,len,flags)  zend_register_stringl_constant((name),sizeof(name),(str),(len),(flags),0 ELS_CC)

 void clean_module_constants(int module_number);
-void free_zend_constant(zend_constant *c);
+int free_zend_constant(zend_constant *c);
 int zend_startup_constants(ELS_D);
 int zend_shutdown_constants(ELS_D);
 void zend_register_standard_constants(ELS_D);
@@ -55,10 +55,9 @@ ZEND_API void zend_register_long_constant(char *name, uint name_len, long lval,
 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);
+ZEND_API void zend_register_constant(zend_constant *c ELS_DC);
 void zend_copy_constants(HashTable *target, HashTable *sourc);
-void copy_zend_constant(zend_constant *c);

-#define ZEND_CONSTANT_DTOR (void (*)(void *)) free_zend_constant
+#define ZEND_CONSTANT_DTOR (int (*)(void *)) free_zend_constant

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


-#ifndef ZEND_ERRORS_H
-#define ZEND_ERRORS_H
+#ifndef _ZEND_ERRORS_H
+#define _ZEND_ERRORS_H

 #define E_ERROR				(1<<0L)
 #define E_WARNING			(1<<1L)
@@ -29,12 +29,9 @@
 #define E_CORE_WARNING		(1<<5L)
 #define E_COMPILE_ERROR		(1<<6L)
 #define E_COMPILE_WARNING	(1<<7L)
-#define E_USER_ERROR		(1<<8L)
-#define E_USER_WARNING		(1<<9L)
-#define E_USER_NOTICE		(1<<10L)

-#define E_ALL (E_ERROR | E_WARNING | E_PARSE | E_NOTICE | E_CORE_ERROR | E_CORE_WARNING | E_COMPILE_ERROR | E_COMPILE_WARNING | E_USER_ERROR | E_USER_WARNING | E_USER_NOTICE)
+#define E_ALL (E_ERROR | E_WARNING | E_PARSE | E_NOTICE | E_CORE_ERROR | E_CORE_WARNING | E_COMPILE_ERROR | E_COMPILE_WARNING)
 #define E_CORE (E_CORE_ERROR | E_CORE_WARNING)

-#endif /* ZEND_ERRORS_H */
+#endif /* _ZEND_ERRORS_H */

@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -18,13 +18,11 @@
 */


-#ifndef ZEND_EXECUTE_H
-#define ZEND_EXECUTE_H
+#ifndef _EXECUTE_H
+#define _EXECUTE_H

 #include "zend_compile.h"
 #include "zend_hash.h"
-#include "zend_variables.h"
-#include "zend_execute_locks.h"

 typedef union _temp_variable {
 	zval tmp_var;
@@ -35,14 +33,8 @@ typedef union _temp_variable {
 	struct {
 		zval tmp_var; /* a dummy */

-		union {
-			struct {
-				zval *str;
-				int offset;
-			} str_offset;
-			zend_property_reference overloaded_element;
-		} data;
-			
+		zval *str;
+		int offset;
 		unsigned char type;
 	} EA;
 } temp_variable;
@@ -54,79 +46,15 @@ void init_executor(CLS_D ELS_DC);
 void shutdown_executor(ELS_D);
 void execute(zend_op_array *op_array ELS_DC);
 ZEND_API int zend_is_true(zval *op);
-static inline void safe_free_zval_ptr(zval *p)
-{
-	ELS_FETCH();
-
-	if (p!=EG(uninitialized_zval_ptr)) {
-		FREE_ZVAL(p);
-	}
-}
-
-ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name CLS_DC ELS_DC);
-static inline int i_zend_is_true(zval *op)
-{
-	int result;
-
-	switch (op->type) {
-		case IS_NULL:
-			result = 0;
-			break;
-		case IS_LONG:
-		case IS_BOOL:
-		case IS_RESOURCE:
-			result = (op->value.lval?1:0);
-			break;
-		case IS_DOUBLE:
-			result = (op->value.dval ? 1 : 0);
-			break;
-		case IS_STRING:
-			if (op->value.str.len == 0
-				|| (op->value.str.len==1 && op->value.str.val[0]=='0')) {
-				result = 0;
-			} else {
-				result = 1;
-			}
-			break;
-		case IS_ARRAY:
-			result = (zend_hash_num_elements(op->value.ht)?1:0);
-			break;
-		case IS_OBJECT:
-			result = (zend_hash_num_elements(op->value.obj.properties)?1:0);
-			break;
-		default:
-			result = 0;
-			break;
-	}
-	return result;
-}
-
-ZEND_API int zval_update_constant(zval **pp, void *arg);
+ZEND_API inline void safe_free_zval_ptr(zval *p);
+ZEND_API void zend_eval_string(char *str, zval *retval CLS_DC ELS_DC);
+ZEND_API inline int i_zend_is_true(zval *op);
+ZEND_API void zval_update_constant(zval *p);
+ZEND_API inline void zend_assign_to_variable_reference(znode *result, zval **variable_ptr_ptr, zval **value_ptr_ptr, temp_variable *Ts ELS_DC);

 /* dedicated Zend executor functions - do not use! */
-static inline void zend_ptr_stack_clear_multiple(ELS_D)
-{
-	void **p = EG(argument_stack).top_element-2;
-	int delete_count = (ulong) *p;
-
-	EG(argument_stack).top -= (delete_count+2);
-	while (--delete_count>=0) {
-		zval_ptr_dtor((zval **) --p);
-	}
-	EG(argument_stack).top_element = p;
-}
-
-static inline int zend_ptr_stack_get_arg(int requested_arg, void **data ELS_DC)
-{
-	void **p = EG(argument_stack).top_element-2;
-	int arg_count = (ulong) *p;
-
-	if (requested_arg>arg_count) {
-		return FAILURE;
-	}
-	*data = (p-arg_count+requested_arg-1);
-	return SUCCESS;
-}
+ZEND_API inline void zend_ptr_stack_clear_multiple(ELS_D);
+ZEND_API inline int zend_ptr_stack_get_arg(int requested_arg, void **data ELS_DC);

 #if SUPPORT_INTERACTIVE
 void execute_new_code(CLS_D);
@@ -134,80 +62,17 @@ void execute_new_code(CLS_D);


 /* services */
-ZEND_API char *get_active_function_name(void);
+ZEND_API char *get_active_function_name();
 ZEND_API char *zend_get_executed_filename(ELS_D);
 ZEND_API uint zend_get_executed_lineno(ELS_D);
-ZEND_API zend_bool zend_is_executing(void);
-
-ZEND_API void zend_set_timeout(long seconds);
-ZEND_API void zend_unset_timeout(void);
-ZEND_API void zend_timeout(int dummy);
-
-#ifdef ZEND_WIN32
-void zend_init_timeout_thread();
-void zend_shutdown_timeout_thread();
-#define WM_REGISTER_ZEND_TIMEOUT		(WM_USER+1)
-#define WM_UNREGISTER_ZEND_TIMEOUT		(WM_USER+2)
-#endif

 #define zendi_zval_copy_ctor(p) zval_copy_ctor(&(p))
 #define zendi_zval_dtor(p) zval_dtor(&(p))

 #define active_opline (*EG(opline_ptr))

-static inline void zend_assign_to_variable_reference(znode *result, zval **variable_ptr_ptr, zval **value_ptr_ptr, temp_variable *Ts ELS_DC)
-{
-	zval *variable_ptr;
-	zval *value_ptr;
-
-	if (!value_ptr_ptr || !variable_ptr_ptr) {
-		zend_error(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects");
-		return;
-	}
-
-	variable_ptr = *variable_ptr_ptr;
-	value_ptr = *value_ptr_ptr;
-
-	if (variable_ptr == EG(error_zval_ptr) || value_ptr==EG(error_zval_ptr)) {
-		variable_ptr_ptr = &EG(uninitialized_zval_ptr);
-/*	} else if (variable_ptr==&EG(uninitialized_zval) || variable_ptr!=value_ptr) { */
-	} else if (variable_ptr_ptr != value_ptr_ptr) {
-		variable_ptr->refcount--;
-		if (variable_ptr->refcount==0) {
-			zendi_zval_dtor(*variable_ptr);
-			FREE_ZVAL(variable_ptr);
-		}
-
-		if (!PZVAL_IS_REF(value_ptr)) {
-			/* break it away */
-			value_ptr->refcount--;
-			if (value_ptr->refcount>0) {
-				ALLOC_ZVAL(*value_ptr_ptr);
-				**value_ptr_ptr = *value_ptr;
-				value_ptr = *value_ptr_ptr;
-				zendi_zval_copy_ctor(*value_ptr);
-			}
-			value_ptr->refcount = 1;
-			value_ptr->is_ref = 1;
-		}
-
-		*variable_ptr_ptr = value_ptr;
-		value_ptr->refcount++;
-	} else {
-		if (variable_ptr->refcount>1) { /* we need to break away */
-			SEPARATE_ZVAL(variable_ptr_ptr);
-		}
-		(*variable_ptr_ptr)->is_ref = 1;
-	}
-
-	if (result && !(result->u.EA.type & EXT_TYPE_UNUSED)) {
-		Ts[result->u.var].var.ptr_ptr = variable_ptr_ptr;
-		SELECTIVE_PZVAL_LOCK(*variable_ptr_ptr, result);
-		AI_USE_PTR(Ts[result->u.var].var);
-	}
-}

 #define IS_OVERLOADED_OBJECT 1
 #define IS_STRING_OFFSET 2

-#endif /* ZEND_EXECUTE_H */
+#endif /* _EXECUTE_H */
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -26,26 +26,14 @@
 #include "zend_execute.h"
 #include "zend_API.h"
 #include "zend_ptr_stack.h"
+#include "zend_variables.h"
+#include "zend_operators.h"
 #include "zend_constants.h"
 #include "zend_extensions.h"
-#include "zend_execute_locks.h"
-#if HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif


 ZEND_API void (*zend_execute)(zend_op_array *op_array ELS_DC);

-#ifdef ZEND_WIN32
-#include <process.h>
-/* true global */
-static WNDCLASS wc;
-static HWND timeout_window;
-static HANDLE timeout_thread_event;
-static DWORD timeout_thread_id;
-static int timeout_thread_initialized=0;
-#endif
-

 #if ZEND_DEBUG
 static void (*original_sigsegv_handler)(int);
@@ -91,32 +79,26 @@ static void zend_extension_deactivator(zend_extension *extension)
 }


-static int is_not_internal_function(zend_function *function)
-{
-	return(function->type != ZEND_INTERNAL_FUNCTION);
-}
-
-
-static int is_not_internal_class(zend_class_entry *ce)
-{
-	return(ce->type != ZEND_INTERNAL_CLASS);
-}
-
-
 void init_executor(CLS_D ELS_DC)
 {
-	INIT_ZVAL(EG(uninitialized_zval));
-	INIT_ZVAL(EG(error_zval));
+	var_uninit(&EG(uninitialized_zval));
+	var_uninit(&EG(error_zval));
+	EG(uninitialized_zval).refcount = 1;
+	EG(uninitialized_zval).is_ref=0;
 	EG(uninitialized_zval_ptr)=&EG(uninitialized_zval);
+	EG(error_zval).refcount = 1;
+	EG(error_zval).is_ref=0;
 	EG(error_zval_ptr)=&EG(error_zval);
 	zend_ptr_stack_init(&EG(arg_types_stack));
+	zend_stack_init(&EG(overloaded_objects_stack));
 /* destroys stack frame, therefore makes core dumps worthless */
-#if 0&&ZEND_DEBUG
+#if 0
+#if ZEND_DEBUG
 	original_sigsegv_handler = signal(SIGSEGV, zend_handle_sigsegv);
 #endif
-	EG(return_value_ptr_ptr) = &EG(global_return_value_ptr);
-	EG(global_return_value_ptr) = NULL;
-
+#endif
+	EG(return_value) = &EG(global_return_value);
+	var_reset(EG(return_value));
 	EG(symtable_cache_ptr) = EG(symtable_cache)-1;
 	EG(symtable_cache_limit)=EG(symtable_cache)+SYMTABLE_CACHE_SIZE-1;
 	EG(no_extensions)=0;
@@ -124,36 +106,23 @@ void init_executor(CLS_D ELS_DC)
 	EG(function_table) = CG(function_table);
 	EG(class_table) = CG(class_table);

-	EG(in_execution) = 0;
-
 	zend_ptr_stack_init(&EG(argument_stack));

-	zend_hash_init(&EG(symbol_table), 50, NULL, ZVAL_PTR_DTOR, 0);
+	EG(main_op_array) = NULL;
+	zend_hash_init(&EG(symbol_table), 50, NULL, PVAL_PTR_DTOR, 0);
 	EG(active_symbol_table) = &EG(symbol_table);

 	zend_llist_apply(&zend_extensions, (void (*)(void *)) zend_extension_activator);
 	EG(opline_ptr) = NULL;
 	EG(garbage_ptr) = 0;
-
-	zend_hash_init(&EG(included_files), 5, NULL, NULL, 0);
-
-	EG(ticks_count) = 0;
-
-	EG(user_error_handler) = NULL;
-
-	zend_ptr_stack_init(&EG(user_error_handlers));
-
-	EG(orig_error_reporting) = EG(error_reporting);
-
-#ifdef ZEND_WIN32
-	EG(timed_out) = 0;
-#endif
 }


 void shutdown_executor(ELS_D)
 {
+	zval_dtor(&EG(global_return_value));
 	zend_ptr_stack_destroy(&EG(arg_types_stack));
+	zend_stack_destroy(&EG(overloaded_objects_stack));
 			
 	while (EG(symtable_cache_ptr)>=EG(symtable_cache)) {
 		zend_hash_destroy(*EG(symtable_cache_ptr));
@@ -164,38 +133,21 @@ void shutdown_executor(ELS_D)

 	zend_hash_destroy(&EG(symbol_table));

-	while (EG(garbage_ptr)--) {
-		if (EG(garbage)[EG(garbage_ptr)]->refcount==1) {
-			zval_ptr_dtor(&EG(garbage)[EG(garbage_ptr)]);
-		}
-	}
+	destroy_resource_list(); /* must be destroyed after the main symbol table is destroyed */

 	zend_ptr_stack_destroy(&EG(argument_stack));
-
-	/* Destroy all op arrays */
-	zend_hash_apply(EG(function_table), (int (*)(void *)) is_not_internal_function);
-	zend_hash_apply(EG(class_table), (int (*)(void *)) is_not_internal_class);
-
-	zend_destroy_rsrc_list(ELS_C); /* must be destroyed after the main symbol table and
-									* op arrays are destroyed.
-									*/
-
+	if (EG(main_op_array)) {
+		destroy_op_array(EG(main_op_array));
+		efree(EG(main_op_array));
+	}
 	clean_non_persistent_constants();
 #if ZEND_DEBUG
 	signal(SIGSEGV, original_sigsegv_handler);
 #endif
-
-	zend_hash_destroy(&EG(included_files));
-
-	if (EG(user_error_handler)) {
-		zval_dtor(EG(user_error_handler));
-		FREE_ZVAL(EG(user_error_handler));
+	while (EG(garbage_ptr)--) {
+		zval_dtor(EG(garbage)[EG(garbage_ptr)]);
+		efree(EG(garbage)[EG(garbage_ptr)]);
 	}
-
-	zend_ptr_stack_clean(&EG(user_error_handlers), ZVAL_DESTRUCTOR, 1);
-	zend_ptr_stack_destroy(&EG(user_error_handlers));
-
-	EG(error_reporting) = EG(orig_error_reporting);
 }


@@ -225,8 +177,8 @@ ZEND_API char *get_active_function_name()

 ZEND_API char *zend_get_executed_filename(ELS_D)
 {
-	if (EG(active_op_array)) {
-		return EG(active_op_array)->filename;
+	if (EG(opline_ptr)) {
+		return active_opline->filename;
 	} else {
 		return "[no active file]";
 	}
@@ -243,15 +195,17 @@ ZEND_API uint zend_get_executed_lineno(ELS_D)
 }


-ZEND_API zend_bool zend_is_executing()
+ZEND_API inline void safe_free_zval_ptr(zval *p)
 {
 	ELS_FETCH();

-	return EG(in_execution);
+	if (p!=EG(uninitialized_zval_ptr)) {
+		efree(p);
+	}
 }


-ZEND_API void _zval_ptr_dtor(zval **zval_ptr ZEND_FILE_LINE_DC)
+ZEND_API int _zval_ptr_dtor(zval **zval_ptr ZEND_FILE_LINE_DC)
 {
 #if DEBUG_ZEND>=2
 	printf("Reducing refcount for %x (%x):  %d->%d\n", *zval_ptr, zval_ptr, (*zval_ptr)->refcount, (*zval_ptr)->refcount-1);
@@ -260,11 +214,45 @@ ZEND_API void _zval_ptr_dtor(zval **zval_ptr ZEND_FILE_LINE_DC)
 	if ((*zval_ptr)->refcount==0) {
 		zval_dtor(*zval_ptr);
 		safe_free_zval_ptr(*zval_ptr);
-	} else if (((*zval_ptr)->refcount == 1) && ((*zval_ptr)->type != IS_OBJECT)) {
-		(*zval_ptr)->is_ref = 0;
 	}
+	return 1;
 }
-	
+
+
+ZEND_API inline int i_zend_is_true(zval *op)
+{
+	int result;
+
+	switch (op->type) {
+		case IS_LONG:
+		case IS_BOOL:
+		case IS_RESOURCE:
+			result = (op->value.lval?1:0);
+			break;
+		case IS_DOUBLE:
+			result = (op->value.dval ? 1 : 0);
+			break;
+		case IS_STRING:
+			if (op->value.str.len == 0
+				|| (op->value.str.len==1 && op->value.str.val[0]=='0')) {
+				result = 0;
+			} else {
+				result = 1;
+			}
+			break;
+		case IS_ARRAY:
+			result = (zend_hash_num_elements(op->value.ht)?1:0);
+			break;
+		case IS_OBJECT:
+			result = (zend_hash_num_elements(op->value.obj.properties)?1:0);
+			break;
+		default:
+			result = 0;
+			break;
+	}
+	return result;
+}
+

 ZEND_API int zend_is_true(zval *op)
 {
@@ -272,106 +260,60 @@ ZEND_API int zend_is_true(zval *op)
 }


-ZEND_API int zval_update_constant(zval **pp, void *arg)
+ZEND_API void zval_update_constant(zval *p)
 {
-	zval *p = *pp;
-	zend_bool inline_change = (zend_bool) (unsigned long) arg;
-
 	if (p->type == IS_CONSTANT) {
 		zval c;
-		int refcount;
-
-		SEPARATE_ZVAL(pp);
-		p = *pp;
-
-		refcount = p->refcount;
+		int refcount = p->refcount;

 		if (!zend_get_constant(p->value.str.val, p->value.str.len, &c)) {
 			zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'",
 						p->value.str.val,
 						p->value.str.val);
 			p->type = IS_STRING;
-			if (!inline_change) {
-				zval_copy_ctor(p);
-			}
 		} else {
-			if (inline_change) {
-				STR_FREE(p->value.str.val);
-			}
+			STR_FREE(p->value.str.val);
 			*p = c;
 		}
 		INIT_PZVAL(p);
 		p->refcount = refcount;
-	} else if (p->type == IS_CONSTANT_ARRAY) {
-		SEPARATE_ZVAL(pp);
-		p = *pp;
-		p->type = IS_ARRAY;
-		zend_hash_apply_with_argument(p->value.ht, (int (*)(void *,void *)) zval_update_constant, (void *) 1);
 	}
-	return 0;
 }


-int call_user_function(HashTable *function_table, zval *object, zval *function_name, zval *retval_ptr, int param_count, zval *params[])
+int call_user_function(HashTable *function_table, zval *object, zval *function_name, zval *retval, int param_count, zval *params[])
 {
 	zval ***params_array = (zval ***) emalloc(sizeof(zval **)*param_count);
 	int i;
 	int ex_retval;
-	zval *local_retval_ptr;

 	for (i=0; i<param_count; i++) {
 		params_array[i] = &params[i];
 	}
-	ex_retval = call_user_function_ex(function_table, object, function_name, &local_retval_ptr, param_count, params_array, 1, NULL);
-	if (local_retval_ptr) {
-		COPY_PZVAL_TO_ZVAL(*retval_ptr, local_retval_ptr);
-	} else {
-		INIT_ZVAL(*retval_ptr);
-	}
+	ex_retval = call_user_function_ex(function_table, object, function_name, retval, param_count, params_array, 1);
 	efree(params_array);
 	return ex_retval;
 }


-int call_user_function_ex(HashTable *function_table, zval *object, zval *function_name, zval **retval_ptr_ptr, int param_count, zval **params[], int no_separation, HashTable *symbol_table)
+int call_user_function_ex(HashTable *function_table, zval *object, zval *function_name, zval *retval, int param_count, zval **params[], int no_separation)
 {
 	int i;
-	zval **original_return_value;
+	zval *original_return_value;
 	HashTable *calling_symbol_table;
 	zend_function_state function_state;
 	zend_function_state *original_function_state_ptr;
 	zend_op_array *original_op_array;
 	zend_op **original_opline_ptr;
+	CLS_FETCH();
 	ELS_FETCH();

-	*retval_ptr_ptr = NULL;
-
-	if (function_name->type==IS_ARRAY) { /* assume array($obj, $name) couple */
-		zval **tmp_object_ptr, **tmp_real_function_name;
-
-		if (zend_hash_index_find(function_name->value.ht, 0, (void **) &tmp_object_ptr)==FAILURE) {
-			return FAILURE;
-		}
-		if (zend_hash_index_find(function_name->value.ht, 1, (void **) &tmp_real_function_name)==FAILURE) {
-			return FAILURE;
-		}
-		function_name = *tmp_real_function_name;
-		SEPARATE_ZVAL_IF_NOT_REF(tmp_object_ptr);
-		object = *tmp_object_ptr;
-		object->is_ref = 1;
-	}
-
 	if (object) {
 		if (object->type != IS_OBJECT) {
 			return FAILURE;
 		}
 		function_table = &object->value.obj.ce->function_table;
 	}
-
-	if (function_name->type!=IS_STRING) {
-		return FAILURE;
-	}
-
 	original_function_state_ptr = EG(function_state_ptr);
 	zend_str_tolower(function_name->value.str.val, function_name->value.str.len);
 	if (zend_hash_find(function_table, function_name->value.str.val, function_name->value.str.len+1, (void **) &function_state.function)==FAILURE) {
@@ -391,7 +333,7 @@ int call_user_function_ex(HashTable *function_table, zval *object, zval *functio
 				if (no_separation) {
 					return FAILURE;
 				}
-				ALLOC_ZVAL(new_zval);
+				new_zval = (zval *) emalloc(sizeof(zval));
 				*new_zval = **params[i];
 				zval_copy_ctor(new_zval);
 				new_zval->refcount = 1;
@@ -405,50 +347,42 @@ int call_user_function_ex(HashTable *function_table, zval *object, zval *functio
 			(*params[i])->refcount++;
 			param = *params[i];
 		} else {
-			ALLOC_ZVAL(param);
+			param = (zval *) emalloc(sizeof(zval));
 			*param = **(params[i]);
 			INIT_PZVAL(param);
 		}
 		zend_ptr_stack_push(&EG(argument_stack), param);
 	}

-	zend_ptr_stack_n_push(&EG(argument_stack), 2, (void *) (long) param_count, NULL);
+	zend_ptr_stack_push(&EG(argument_stack), (void *) (long) param_count);

+	var_uninit(retval);
 	if (function_state.function->type == ZEND_USER_FUNCTION) {
 		calling_symbol_table = EG(active_symbol_table);
-		if (symbol_table) {
-			EG(active_symbol_table) = symbol_table;
-		} else {
-			ALLOC_HASHTABLE(EG(active_symbol_table));
-			zend_hash_init(EG(active_symbol_table), 0, NULL, ZVAL_PTR_DTOR, 0);
-		}
+		EG(active_symbol_table) = (HashTable *) emalloc(sizeof(HashTable));
+		zend_hash_init(EG(active_symbol_table), 0, NULL, PVAL_PTR_DTOR, 0);
 		if (object) {
-			zval *dummy, **this_ptr;
+			zval *dummy = (zval *) emalloc(sizeof(zval)), **this_ptr;

-			ALLOC_ZVAL(dummy);
-			INIT_ZVAL(*dummy);
-			
-			zend_hash_update(EG(active_symbol_table), "this", sizeof("this"), &dummy, sizeof(zval *), (void **) &this_ptr);
+			var_uninit(dummy);
+			INIT_PZVAL(dummy);
+			zend_hash_update_ptr(EG(active_symbol_table), "this", sizeof("this"), dummy, sizeof(zval *), (void **) &this_ptr);
 			zend_assign_to_variable_reference(NULL, this_ptr, &object, NULL ELS_CC);
 		}
-		original_return_value = EG(return_value_ptr_ptr);
+		original_return_value = EG(return_value);
 		original_op_array = EG(active_op_array);
-		EG(return_value_ptr_ptr) = retval_ptr_ptr;
+		EG(return_value) = retval;
 		EG(active_op_array) = (zend_op_array *) function_state.function;
-		original_opline_ptr = EG(opline_ptr);
+		original_opline_ptr = EG(opline_ptr);	
 		zend_execute(EG(active_op_array) ELS_CC);
-		if (!symbol_table) {
-			zend_hash_destroy(EG(active_symbol_table));
-			FREE_HASHTABLE(EG(active_symbol_table));
-		}
+		zend_hash_destroy(EG(active_symbol_table));		
+		efree(EG(active_symbol_table));
 		EG(active_symbol_table) = calling_symbol_table;
 		EG(active_op_array) = original_op_array;
-		EG(return_value_ptr_ptr)=original_return_value;
+		EG(return_value)=original_return_value;
 		EG(opline_ptr) = original_opline_ptr;
 	} else {
-		ALLOC_INIT_ZVAL(*retval_ptr_ptr);
-		((zend_internal_function *) function_state.function)->handler(param_count, *retval_ptr_ptr, object, 1 ELS_CC);
-		INIT_PZVAL(*retval_ptr_ptr);
+		((zend_internal_function *) function_state.function)->handler(param_count, retval, &EG(regular_list), &EG(persistent_list), object);
 	}
 	zend_ptr_stack_clear_multiple(ELS_C);
 	EG(function_state_ptr) = original_function_state_ptr;
@@ -457,16 +391,15 @@ int call_user_function_ex(HashTable *function_table, zval *object, zval *functio
 }


-ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name CLS_DC ELS_DC)
+ZEND_API void zend_eval_string(char *str, zval *retval CLS_DC ELS_DC)
 {
 	zval pv;
 	zend_op_array *new_op_array;
 	zend_op_array *original_active_op_array = EG(active_op_array);
 	zend_function_state *original_function_state_ptr = EG(function_state_ptr);
 	int original_handle_op_arrays;
-	int retval;

-	if (retval_ptr) {
+	if (retval) {
 		pv.value.str.len = strlen(str)+sizeof("return  ;")-1;
 		pv.value.str.val = emalloc(pv.value.str.len+1);
 		strcpy(pv.value.str.val, "return ");
@@ -482,48 +415,84 @@ ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name CLS

 	original_handle_op_arrays = CG(handle_op_arrays);
 	CG(handle_op_arrays) = 0;
-	new_op_array = compile_string(&pv, string_name CLS_CC);
+	new_op_array = compile_string(&pv CLS_CC);
 	CG(handle_op_arrays) = original_handle_op_arrays;

 	if (new_op_array) {
-		zval *local_retval_ptr=NULL;
-		zval **original_return_value_ptr_ptr = EG(return_value_ptr_ptr);
+		zval dummy_retval;
+		zval *original_return_value = EG(return_value);
 		zend_op **original_opline_ptr = EG(opline_ptr);
 		
-		EG(return_value_ptr_ptr) = &local_retval_ptr;
+		EG(return_value) = (retval?retval:&dummy_retval);
+		var_reset(EG(return_value));
 		EG(active_op_array) = new_op_array;
 		EG(no_extensions)=1;
-
 		zend_execute(new_op_array ELS_CC);
-
-		if (local_retval_ptr) {
-			if (retval_ptr) {
-				COPY_PZVAL_TO_ZVAL(*retval_ptr, local_retval_ptr);
-			} else {
-				zval_ptr_dtor(&local_retval_ptr);
-			}
-		} else {
-			if (retval_ptr) {
-				INIT_ZVAL(*retval_ptr);
-			}
-		}
-
 		EG(no_extensions)=0;
 		EG(opline_ptr) = original_opline_ptr;
 		EG(active_op_array) = original_active_op_array;
 		EG(function_state_ptr) = original_function_state_ptr;
 		destroy_op_array(new_op_array);
 		efree(new_op_array);
-		EG(return_value_ptr_ptr) = original_return_value_ptr_ptr;
-		retval = SUCCESS;
+		EG(return_value) = original_return_value;
+		if (!retval) {
+			zval_dtor(&dummy_retval);
+		}
 	} else {
-		retval = FAILURE;
+		printf("Failed executing:\n%s\n", str);
 	}
 	zval_dtor(&pv);
-	return retval;
 }


+ZEND_API inline void zend_assign_to_variable_reference(znode *result, zval **variable_ptr_ptr, zval **value_ptr_ptr, temp_variable *Ts ELS_DC)
+{
+	zval *variable_ptr = *variable_ptr_ptr;
+	zval *value_ptr;
+	
+
+	if (!value_ptr_ptr) {
+		zend_error(E_ERROR, "Cannot create references to string offsets nor overloaded objects");
+		return;
+	}
+
+	value_ptr = *value_ptr_ptr;
+	if (variable_ptr == EG(error_zval_ptr) || value_ptr==EG(error_zval_ptr)) {
+		variable_ptr_ptr = &EG(uninitialized_zval_ptr);
+/*	} else if (variable_ptr==&EG(uninitialized_zval) || variable_ptr!=value_ptr) { */
+	} else if (variable_ptr_ptr != value_ptr_ptr) {
+		variable_ptr->refcount--;
+		if (variable_ptr->refcount==0) {
+			zendi_zval_dtor(*variable_ptr);
+			efree(variable_ptr);
+		}
+
+		if (!PZVAL_IS_REF(value_ptr)) {
+			/* break it away */
+			value_ptr->refcount--;
+			if (value_ptr->refcount>0) {
+				*value_ptr_ptr = (zval *) emalloc(sizeof(zval));
+				**value_ptr_ptr = *value_ptr;
+				value_ptr = *value_ptr_ptr;
+				zendi_zval_copy_ctor(*value_ptr);
+			}
+			value_ptr->refcount = 1;
+			value_ptr->is_ref = 1;
+		}
+
+		*variable_ptr_ptr = value_ptr;
+		value_ptr->refcount++;
+	} else {
+		/* nothing to do */
+	}
+
+	if (result && (result->op_type != IS_UNUSED)) {
+		Ts[result->u.var].var.ptr_ptr = variable_ptr_ptr;
+		SELECTIVE_PZVAL_LOCK(*variable_ptr_ptr, result);
+		AI_USE_PTR(Ts[result->u.var].var);
+	}
+}
+

 #if SUPPORT_INTERACTIVE
 void execute_new_code(CLS_D)
@@ -540,169 +509,37 @@ void execute_new_code(CLS_D)
 	CG(active_op_array)->end_op_number = CG(active_op_array)->last;
 	EG(active_op_array) = CG(active_op_array);
 	zend_execute(CG(active_op_array) ELS_CC);
-	zval_ptr_dtor(EG(return_value_ptr_ptr));
 	CG(active_op_array)->start_op_number = CG(active_op_array)->last_executed_op_number;
 }
 #endif


-ZEND_API void zend_timeout(int dummy)
+/* these are a dedicated, optimized, function, and shouldn't be used for any purpose
+ * other than by Zend's executor
+ */
+ZEND_API inline void zend_ptr_stack_clear_multiple(ELS_D)
 {
-	ELS_FETCH();
+	void **p = EG(argument_stack).top_element-1;
+	int delete_count = (ulong) *p;

-	/* is there any point in this?  we're terminating the request anyway...
-	PLS_FETCH();
-
-	PG(connection_status) |= PHP_CONNECTION_TIMEOUT;
-	*/
-	zend_error(E_ERROR, "Maximum execution time of %d second%s exceeded",
-			  EG(timeout_seconds), EG(timeout_seconds) == 1 ? "" : "s");
-}
-
-
-#ifdef ZEND_WIN32
-static LRESULT CALLBACK zend_timeout_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) 
-{
-	switch (message) {
-		case WM_DESTROY:
-			PostQuitMessage(0);
-			break;
-		case WM_REGISTER_ZEND_TIMEOUT:
-			/* wParam is the thread id pointer, lParam is the timeout amount in seconds */
-			if (lParam==0) {
-				KillTimer(timeout_window, wParam);
-			} else {
-				SetTimer(timeout_window, wParam, lParam*1000, NULL);
-			}
-			break;
-		case WM_UNREGISTER_ZEND_TIMEOUT:
-			/* wParam is the thread id pointer */
-			KillTimer(timeout_window, wParam);
-			break;
-		case WM_TIMER: {
-#ifdef ZTS
-				zend_executor_globals *executor_globals;
-
-				executor_globals = ts_resource_ex(executor_globals_id, &wParam);
-				if (!executor_globals) {
-					/* Thread died before receiving its timeout? */
-					break;
-				}
-#endif
-				KillTimer(timeout_window, wParam);
-				EG(timed_out) = 1;
-			}
-			break;
-		default:
-			return DefWindowProc(hWnd,message,wParam,lParam);
+	EG(argument_stack).top -= (delete_count+1);
+	while (--delete_count>=0) {
+		zval_ptr_dtor((zval **) --p);
 	}
-	return 0;
+	EG(argument_stack).top_element = p;
 }



-static unsigned __stdcall timeout_thread_proc(void *pArgs)
+ZEND_API int zend_ptr_stack_get_arg(int requested_arg, void **data ELS_DC)
 {
-	MSG message;
+	void **p = EG(argument_stack).top_element-1;
+	int arg_count = (ulong) *p;

-	wc.style=0;
-	wc.lpfnWndProc = zend_timeout_WndProc;
-	wc.cbClsExtra=0;
-	wc.cbWndExtra=0;
-	wc.hInstance=NULL;
-	wc.hIcon=NULL;
-	wc.hCursor=NULL;
-	wc.hbrBackground=(HBRUSH)(COLOR_BACKGROUND + 5);
-	wc.lpszMenuName=NULL;
-	wc.lpszClassName = "Zend Timeout Window";
-	if(!RegisterClass(&wc)) {
-		return -1;
+	if (requested_arg>arg_count) {
+		return FAILURE;
 	}
-	timeout_window = CreateWindow(wc.lpszClassName, wc.lpszClassName, 0, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, NULL, NULL);
-	SetEvent(timeout_thread_event);
-	while (GetMessage(&message, NULL, 0, 0)) {
-		SendMessage(timeout_window, message.message, message.wParam, message.lParam);
-		if (message.message == WM_QUIT) {
-			break;
-		}
-	}
-	DestroyWindow(timeout_window);
-	UnregisterClass(wc.lpszClassName, NULL);
-	return 0;
+	*data = (p-arg_count+requested_arg-1);
+	return SUCCESS;
 }

-
-void zend_init_timeout_thread()
-{
-	timeout_thread_event = CreateEvent(NULL, FALSE, FALSE, NULL);
-	_beginthreadex(NULL, 0, timeout_thread_proc, NULL, 0, &timeout_thread_id);
-	WaitForSingleObject(timeout_thread_event, INFINITE);
-}
-
-
-void zend_shutdown_timeout_thread()
-{
-	if (!timeout_thread_initialized) {
-		return;
-	}
-	PostThreadMessage(timeout_thread_id, WM_QUIT, 0, 0);
-}
-
-#endif
-
-/* This one doesn't exists on QNX */
-#ifndef SIGPROF
-#define SIGPROF 27
-#endif
-
-void zend_set_timeout(long seconds)
-{
-	ELS_FETCH();
-
-	EG(timeout_seconds) = seconds;
-#ifdef ZEND_WIN32
-	if (timeout_thread_initialized==0 && InterlockedIncrement(&timeout_thread_initialized)==1) {
-		/* We start up this process-wide thread here and not in zend_startup(), because if Zend
-		 * is initialized inside a DllMain(), you're not supposed to start threads from it.
-		 */
-		zend_init_timeout_thread();
-	}
-	PostThreadMessage(timeout_thread_id, WM_REGISTER_ZEND_TIMEOUT, (WPARAM) GetCurrentThreadId(), (LPARAM) seconds);
-#else
-#	ifdef HAVE_SETITIMER
-	{
-		struct itimerval t_r;		/* timeout requested */
-		sigset_t sigset;
-
-		t_r.it_value.tv_sec = seconds;
-		t_r.it_value.tv_usec = t_r.it_interval.tv_sec = t_r.it_interval.tv_usec = 0;
-
-		setitimer(ITIMER_PROF, &t_r, NULL);
-		signal(SIGPROF, zend_timeout);
-		sigemptyset(&sigset);
-		sigaddset(&sigset, SIGPROF);
-		sigprocmask(SIG_UNBLOCK,&sigset,NULL);
-	}
-#	endif
-#endif
-}
-
-
-void zend_unset_timeout(void)
-{
-	ELS_FETCH();
-
-#ifdef ZEND_WIN32
-	PostThreadMessage(timeout_thread_id, WM_UNREGISTER_ZEND_TIMEOUT, (WPARAM) GetCurrentThreadId(), (LPARAM) 0);
-#else
-#	ifdef HAVE_SETITIMER
-	{
-		struct itimerval no_timeout;
-
-		no_timeout.it_value.tv_sec = no_timeout.it_value.tv_usec = no_timeout.it_interval.tv_sec = no_timeout.it_interval.tv_usec = 0;
-
-		setitimer(ITIMER_PROF, &no_timeout, NULL);
-	}
-#	endif
-#endif
-}
@@ -1,22 +0,0 @@
-#ifndef ZEND_EXECUTE_LOCKS_H
-#define ZEND_EXECUTE_LOCKS_H
-
-#define PZVAL_LOCK(z)	((z)->refcount++)
-#define PZVAL_UNLOCK(z)	{ ((z)->refcount--);								\
-							if (!(z)->refcount) {							\
-								(z)->refcount = 1;							\
-								(z)->is_ref = 0;							\
-								if (EG(garbage_ptr) == 4) {					\
-									zval_ptr_dtor(&EG(garbage)[0]);			\
-									zval_ptr_dtor(&EG(garbage)[1]);			\
-									EG(garbage)[0] = EG(garbage)[2];		\
-									EG(garbage)[1] = EG(garbage)[3];		\
-									EG(garbage_ptr) -= 2;					\
-								}											\
-								EG(garbage)[EG(garbage_ptr)++] = (z);		\
-							}												\
-						}
-
-#define SELECTIVE_PZVAL_LOCK(pzv, pzn)		if (!((pzn)->u.EA.type & EXT_TYPE_UNUSED)) { PZVAL_LOCK(pzv); }
-
-#endif /* ZEND_EXECUTE_LOCKS_H */
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -23,16 +23,33 @@
 ZEND_API zend_llist zend_extensions;
 static int last_resource_number;

+int zend_load_extensions(char **extension_paths)
+{
+	char **p = extension_paths;
+
+	if (!p) {
+		return SUCCESS;
+	}
+	while (*p) {
+		if (zend_load_extension(*p)==FAILURE) {
+			return FAILURE;
+		}
+		p++;
+	}
+	return SUCCESS;
+}
+
+
 int zend_load_extension(char *path)
 {
 #if ZEND_EXTENSIONS_SUPPORT
 	DL_HANDLE handle;
-	zend_extension *new_extension;
+	zend_extension extension, *new_extension;
 	zend_extension_version_info *extension_version_info;

 	handle = DL_LOAD(path);
 	if (!handle) {
-#ifndef ZEND_WIN32
+#if !(WIN32||WINNT)
 		fprintf(stderr, "Failed loading %s:  %s\n", path, dlerror());
 #else
 		fprintf(stderr, "Failed loading %s\n", path);
@@ -47,30 +64,26 @@ int zend_load_extension(char *path)
 		return FAILURE;
 	}

-
-	/* allow extension to proclaim compatibility with any Zend version */
-	if(extension_version_info->zend_extension_api_no != ZEND_EXTENSION_API_NO &&(!new_extension->api_no_check || new_extension->api_no_check(ZEND_EXTENSION_API_NO) != SUCCESS)) {
-		if (extension_version_info->zend_extension_api_no > ZEND_EXTENSION_API_NO) {
-			fprintf(stderr, "%s requires Zend Engine API version %d\n"
-					"The installed Zend Engine API version is %d\n\n",
+	if (extension_version_info->zend_extension_api_no > ZEND_EXTENSION_API_NO) {
+		fprintf(stderr, "%s requires Zend version %s or later\n"
+					"Current version %s, API version %d\n",
 					new_extension->name,
-					extension_version_info->zend_extension_api_no,
+					extension_version_info->required_zend_version,
+					ZEND_VERSION,
 					ZEND_EXTENSION_API_NO);
-			DL_UNLOAD(handle);
-			return FAILURE;
-		} else if (extension_version_info->zend_extension_api_no < ZEND_EXTENSION_API_NO) {
-			fprintf(stderr, "%s designed to be used with the Zend Engine API %d is outdated\n"
-					"It requires a more recent version of the Zend Engine\n"
-					"The installed Zend Engine API version is %d\n"
-					"Contact %s at %s for a later version of this module.\n\n",
+		DL_UNLOAD(handle);
+		return FAILURE;
+	} else if (extension_version_info->zend_extension_api_no < ZEND_EXTENSION_API_NO) {
+		/* we may be able to allow for downwards compatability in some harmless cases. */
+		fprintf(stderr, "%s is outdated (API version %d, current version %d)\n"
+					"Contact %s at %s for a later version of this module.\n",
 					new_extension->name,
 					extension_version_info->zend_extension_api_no,
 					ZEND_EXTENSION_API_NO,
 					new_extension->author,
 					new_extension->URL);
-			DL_UNLOAD(handle);
-			return FAILURE;
-		} 
+		DL_UNLOAD(handle);
+		return FAILURE;
 	} else if (ZTS_V!=extension_version_info->thread_safe) {
 		fprintf(stderr, "Cannot load %s - it %s thread safe, whereas Zend %s\n",
 					new_extension->name,
@@ -87,34 +100,27 @@ int zend_load_extension(char *path)
 		return FAILURE;
 	}

-	return zend_register_extension(new_extension, handle);
+	if (new_extension->startup) {
+		if (new_extension->startup(new_extension)!=SUCCESS) {
+			DL_UNLOAD(handle);
+			return FAILURE;
+		}
+	}
+	extension = *new_extension;
+	extension.handle = handle;
+
+	zend_llist_add_element(&zend_extensions, &extension);
+
+	/*fprintf(stderr, "Loaded %s, version %s\n", extension.name, extension.version);*/
+
+	zend_append_version_info(&extension);
+	return SUCCESS;
 #else
 	fprintf(stderr, "Extensions are not supported on this platform.\n");
 	return FAILURE;
 #endif
 }

-
-int zend_register_extension(zend_extension *new_extension, DL_HANDLE handle)
-{
-#if ZEND_EXTENSIONS_SUPPORT
-	zend_extension extension;
-
-	extension = *new_extension;
-	extension.handle = handle;
-
-	zend_extension_dispatch_message(ZEND_EXTMSG_NEW_EXTENSION, &extension);
-
-	zend_llist_add_element(&zend_extensions, &extension);
-
-	zend_append_version_info(&extension);
-	/*fprintf(stderr, "Loaded %s, version %s\n", extension.name, extension.version);*/
-#endif
-
-	return SUCCESS;
-}
-
-
 static void zend_extension_shutdown(zend_extension *extension)
 {
 #if ZEND_EXTENSIONS_SUPPORT
@@ -124,34 +130,6 @@ static void zend_extension_shutdown(zend_extension *extension)
 #endif
 }

-static int zend_extension_startup(zend_extension *extension)
-{
-#if ZEND_EXTENSIONS_SUPPORT
-	if (extension->startup) {
-		if (extension->startup(extension)!=SUCCESS) {
-			return 1;
-		}
-	}
-#endif
-	return 0;
-}
-
-
-int zend_startup_extensions_mechanism()
-{
-	/* Startup extensions mechanism */
-	zend_llist_init(&zend_extensions, sizeof(zend_extension), (void (*)(void *)) zend_extension_dtor, 1);
-	last_resource_number = 0;
-	return SUCCESS;
-}
-
-
-int zend_startup_extensions()
-{
-	zend_llist_apply_with_del(&zend_extensions, (int (*)(void *)) zend_extension_startup);
-	return SUCCESS;
-}
-

 void zend_shutdown_extensions()
 {
@@ -162,55 +140,18 @@ void zend_shutdown_extensions()

 void zend_extension_dtor(zend_extension *extension)
 {
-#if ZEND_EXTENSIONS_SUPPORT && !ZEND_DEBUG
-	if (extension->handle) {
-		DL_UNLOAD(extension->handle);
-	}
+#if ZEND_EXTENSIONS_SUPPORT
+	DL_UNLOAD(extension->handle);
 #endif
 }


-static void zend_extension_message_dispatcher(zend_extension *extension, int num_args, va_list args)
-{
-	int message;
-	void *arg;
-
-	if (!extension->message_handler || num_args!=2) {
-		return;
-	}
-	message = va_arg(args, int);
-	arg = va_arg(args, void *);
-	extension->message_handler(message, arg);
-}
-
-
-ZEND_API void zend_extension_dispatch_message(int message, void *arg)
-{
-	zend_llist_apply_with_arguments(&zend_extensions, (llist_apply_with_args_func_t) zend_extension_message_dispatcher, 2, message, arg);
-}
-
-
 ZEND_API int zend_get_resource_handle(zend_extension *extension)
 {
-	if (last_resource_number<ZEND_MAX_RESERVED_RESOURCES) {
+	if (last_resource_number<4) {
 		extension->resource_number = last_resource_number;
-		return last_resource_number++;
+		return last_resource_number;
 	} else {
 		return -1;
 	}
 }
-
-
-ZEND_API zend_extension *zend_get_extension(char *extension_name)
-{
-	zend_llist_element *element;
-
-	for (element = zend_extensions.head; element; element = element->next) {
-		zend_extension *extension = (zend_extension *) element->data;
-
-		if (!strcmp(extension->name, extension_name)) {
-			return extension;
-		}
-	}
-	return NULL;
-}
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -18,12 +18,12 @@
 */


-#ifndef ZEND_EXTENSIONS_H
-#define ZEND_EXTENSIONS_H
+#ifndef _ZEND_EXTENSIONS_H
+#define _ZEND_EXTENSIONS_H

 #include "zend_compile.h"

-#define ZEND_EXTENSION_API_NO	20001120	
+#define ZEND_EXTENSION_API_NO		19990619

 typedef struct _zend_extension_version_info {
 	int zend_extension_api_no;
@@ -35,23 +35,6 @@ typedef struct _zend_extension_version_info {

 typedef struct _zend_extension zend_extension;

-/* Typedef's for zend_extension function pointers */
-typedef int (*startup_func_t)(zend_extension *extension);
-typedef void (*shutdown_func_t)(zend_extension *extension);
-typedef void (*activate_func_t)();
-typedef void (*deactivate_func_t)();
-
-typedef void (*message_handler_func_t)(int message, void *arg);
-
-typedef void (*op_array_handler_func_t)(zend_op_array *op_array);
-
-typedef void (*statement_handler_func_t)(zend_op_array *op_array);
-typedef void (*fcall_begin_handler_func_t)(zend_op_array *op_array);
-typedef void (*fcall_end_handler_func_t)(zend_op_array *op_array);
-
-typedef void (*op_array_ctor_func_t)(zend_op_array *op_array);
-typedef void (*op_array_dtor_func_t)(zend_op_array *op_array);
-
 struct _zend_extension {
 	char *name;
 	char *version;
@@ -59,23 +42,21 @@ struct _zend_extension {
 	char *URL;
 	char *copyright;

-	startup_func_t startup;
-	shutdown_func_t shutdown;
-	activate_func_t activate;
-	deactivate_func_t deactivate;
+	int (*startup)(zend_extension *extension);
+	void (*shutdown)(zend_extension *extension);
+	void (*activate)();
+	void (*deactivate)();

-	message_handler_func_t message_handler;
+	void (*op_array_handler)(zend_op_array *op_array);
+	
+	void (*statement_handler)(zend_op_array *op_array);
+	void (*fcall_begin_handler)(zend_op_array *op_array);
+	void (*fcall_end_handler)(zend_op_array *op_array);

-	op_array_handler_func_t op_array_handler;
+	void (*op_array_ctor)(void **resource);
+	void (*op_array_dtor)(void **resource);

-	statement_handler_func_t statement_handler;	
-	fcall_begin_handler_func_t fcall_begin_handler;
-	fcall_end_handler_func_t fcall_end_handler;
-
-	op_array_ctor_func_t op_array_ctor;
-	op_array_dtor_func_t op_array_dtor;
-
-	int (*api_no_check)(int api_no);
+	void *reserved1;
 	void *reserved2;
 	void *reserved3;
 	void *reserved4;
@@ -89,28 +70,27 @@ struct _zend_extension {
 };


-ZEND_API int zend_get_resource_handle(zend_extension *extension);
-ZEND_API void zend_extension_dispatch_message(int message, void *arg);
+ZEND_API int zend_get_resource_handle();

-#define ZEND_EXTMSG_NEW_EXTENSION		1
+#ifdef ZTS
+#define ZTS_V 1
+#else
+#define ZTS_V 0
+#endif


 #define ZEND_EXTENSION()	\
-	ZEND_EXT_API zend_extension_version_info extension_version_info = { ZEND_EXTENSION_API_NO, ZEND_VERSION, ZTS_V, ZEND_DEBUG }
+	ZEND_EXT_API zend_extension_version_info extension_version_info = { ZEND_EXTENSION_API_NO, "0.90", ZTS_V, ZEND_DEBUG }

 #define STANDARD_ZEND_EXTENSION_PROPERTIES NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, -1
-#define COMPAT_ZEND_EXTENSION_PROPERTIES   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, -1


 ZEND_API extern zend_llist zend_extensions;

 void zend_extension_dtor(zend_extension *extension);
-ZEND_API int zend_load_extension(char *path);
-ZEND_API int zend_register_extension(zend_extension *new_extension, DL_HANDLE handle);
+int zend_load_extension(char *path);
+int zend_load_extensions(char **extension_paths);
 void zend_append_version_info(zend_extension *extension);
-int zend_startup_extensions_mechanism(void);
-int zend_startup_extensions(void);
-void zend_shutdown_extensions(void);
-ZEND_API zend_extension *zend_get_extension(char *extension_name);
+void zend_shutdown_extensions();

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


-#ifndef ZEND_GLOBALS_H
-#define ZEND_GLOBALS_H
+#ifndef _T_GLOBALS_H
+#define _T_GLOBALS_H


 #include <setjmp.h>
@@ -30,7 +30,6 @@
 #include "zend_ptr_stack.h"
 #include "zend_hash.h"
 #include "zend_llist.h"
-#include "zend_fast_cache.h"

 /* Define ZTS if you want a thread-safe Zend */
 /*#undef ZTS*/
@@ -40,13 +39,12 @@

 #ifdef __cplusplus
 class ZendFlexLexer;
-class ZendIniFlexLexer;
 #endif

 BEGIN_EXTERN_C()
 ZEND_API extern int compiler_globals_id;
 ZEND_API extern int executor_globals_id;
-ZEND_API extern int alloc_globals_id;
+extern int alloc_globals_id;
 END_EXTERN_C()

 #endif
@@ -55,22 +53,16 @@ END_EXTERN_C()


 #include "zend_compile.h"
+#include "zend_execute.h"

 /* excpt.h on Digital Unix 4.0 defines function_table */
 #undef function_table
-
-
-typedef struct _zend_declarables {
-	zval ticks;
-} zend_declarables;
-
-
+	
 struct _zend_compiler_globals {
 	zend_stack bp_stack;
 	zend_stack switch_cond_stack;
 	zend_stack foreach_copy_stack;
 	zend_stack object_stack;
-	zend_stack declare_stack;

 	zend_class_entry class_entry, *active_class_entry;

@@ -83,7 +75,6 @@ struct _zend_compiler_globals {
 	char *compiled_filename;

 	int zend_lineno;
-	int comment_start_line;
 	char *heredoc;
 	int heredoc_len;

@@ -92,14 +83,10 @@ struct _zend_compiler_globals {
 	HashTable *function_table;	/* function symbol table */
 	HashTable *class_table;		/* class table */

-	HashTable filenames_table;
+	zend_llist filenames_list;

-	zend_bool in_compilation;
 	zend_bool short_tags;
 	zend_bool asp_tags;
-	zend_bool allow_call_time_pass_reference;
-
-	zend_declarables declarables;

 	/* For extensions support */
 	zend_bool extended_info;	/* generate extension information for debugger/profiler */
@@ -107,21 +94,19 @@ struct _zend_compiler_globals {

 	zend_bool unclean_shutdown;

-	zend_bool ini_parser_unbuffered_errors;
-
 	zend_llist open_files;
-#if defined(ZTS) && defined(__cplusplus)
+#ifdef ZTS
+#ifdef __cplusplus
 	ZendFlexLexer *ZFL;
-	ZendIniFlexLexer *ini_scanner;
 #else
 	void *ZFL;
-	void *ini_parser;
+#endif
 #endif
 };


 struct _zend_executor_globals {
-	zval **return_value_ptr_ptr;
+	zval *return_value;

 	zval uninitialized_zval;
 	zval *uninitialized_zval_ptr;
@@ -131,9 +116,8 @@ struct _zend_executor_globals {

 	zend_function_state *function_state_ptr;
 	zend_ptr_stack arg_types_stack;
-
-	/* for global return() support */
-	zval *global_return_value_ptr;
+	zend_stack overloaded_objects_stack;
+	zval global_return_value;

 	/* symbol table cache */
 	HashTable *symtable_cache[SYMTABLE_CACHE_SIZE];
@@ -145,15 +129,12 @@ struct _zend_executor_globals {
 	HashTable *active_symbol_table;
 	HashTable symbol_table;		/* main symbol table */

-	HashTable included_files;	/* files already included */
-
 	jmp_buf bailout;

 	int error_reporting;
-	int orig_error_reporting;
-	int exit_status;

 	zend_op_array *active_op_array;
+	zend_op_array *main_op_array;

 	HashTable *function_table;	/* function symbol table */
 	HashTable *class_table;		/* class table */
@@ -161,17 +142,9 @@ struct _zend_executor_globals {

 	long precision;

-	int ticks_count;
-
-	zend_bool in_execution;
-
 	/* for extended information support */
 	zend_bool no_extensions;

-#ifdef ZEND_WIN32
-	zend_bool timed_out;
-#endif
-
 	HashTable regular_list;
 	HashTable persistent_list;

@@ -183,14 +156,6 @@ struct _zend_executor_globals {
 	zval *garbage[4];
 	int garbage_ptr;

-	zval *user_error_handler;
-	zend_ptr_stack user_error_handlers;
-
-	/* timeout support */
-	int timeout_seconds;
-
-	int lambda_count;
-
 	void *reserved[ZEND_MAX_RESERVED_RESOURCES];
 #if SUPPORT_INTERACTIVE
 	int interactive;
@@ -198,18 +163,13 @@ struct _zend_executor_globals {
 };


-struct _zend_alloc_globals {
-	zend_mem_header *head;		/* standard list */
-	zend_mem_header *phead;		/* persistent list */
-	void *cache[MAX_CACHED_MEMORY][MAX_CACHED_ENTRIES];
-	unsigned int cache_count[MAX_CACHED_MEMORY];
-	void *fast_cache_list_head[MAX_FAST_CACHE_TYPES];

-#if ZEND_DEBUG
-	/* for performance tuning */
-	int cache_stats[MAX_CACHED_MEMORY][2];
-	int fast_cache_stats[MAX_FAST_CACHE_TYPES][2];
-#endif
+struct _zend_alloc_globals {
+	mem_header *head;		/* standard list */
+	mem_header *phead;		/* persistent list */
+	void *cache[MAX_CACHED_MEMORY][MAX_CACHED_ENTRIES];
+	unsigned char cache_count[MAX_CACHED_MEMORY];
+
 #if MEMORY_LIMIT
 	unsigned int memory_limit;
 	unsigned int allocated_memory;
@@ -217,4 +177,5 @@ struct _zend_alloc_globals {
 #endif
 };

-#endif /* ZEND_GLOBALS_H */
+
+#endif /* _T_GLOBALS_H */
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -18,8 +18,8 @@
 */


-#ifndef ZEND_GLOBALS_MACROS_H
-#define ZEND_GLOBALS_MACROS_H
+#ifndef _ZEND_GLOBALS_MACROS_H
+#define _ZEND_GLOBALS_MACROS_H

 typedef struct _zend_compiler_globals zend_compiler_globals;
 typedef struct _zend_executor_globals zend_executor_globals;
@@ -33,18 +33,20 @@ typedef struct _zend_alloc_globals zend_alloc_globals;
 # define CLS_CC , CLS_C
 # define CG(v) (((zend_compiler_globals *) compiler_globals)->v)
 # define CLS_FETCH()	zend_compiler_globals *compiler_globals = (zend_compiler_globals *) ts_resource(compiler_globals_id)
+# define YYPARSE_PARAM compiler_globals
+# define YYLEX_PARAM compiler_globals
 BEGIN_EXTERN_C()
 int zendparse(void *compiler_globals);
 END_EXTERN_C()
 #else
-# define CLS_D	void
+# define CLS_D
 # define CLS_DC
 # define CLS_C
 # define CLS_CC
 # define CG(v) (compiler_globals.v)
 # define CLS_FETCH()
 extern ZEND_API struct _zend_compiler_globals compiler_globals;
-int zendparse(void);
+int zendparse();
 #endif


@@ -57,7 +59,7 @@ int zendparse(void);
 # define EG(v) (executor_globals->v)
 # define ELS_FETCH()	zend_executor_globals *executor_globals = (zend_executor_globals *) ts_resource(executor_globals_id)
 #else
-# define ELS_D	void
+# define ELS_D
 # define ELS_DC
 # define ELS_C
 # define ELS_CC
@@ -76,14 +78,13 @@ extern ZEND_API zend_executor_globals executor_globals;
 # define AG(v) (((zend_alloc_globals *) alloc_globals)->v)
 # define ALS_FETCH()	zend_alloc_globals *alloc_globals = (zend_alloc_globals *) ts_resource(alloc_globals_id)
 #else
-# define ALS_D	void
+# define ALS_D
 # define ALS_DC
 # define ALS_C
 # define ALS_CC
 # define AG(v) (alloc_globals.v)
 # define ALS_FETCH()
-extern ZEND_API zend_alloc_globals alloc_globals;
 #endif

-#endif /* ZEND_GLOBALS_MACROS_H */
+#endif /* _ZEND_GLOBALS_MACROS_H */

@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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,8 +17,8 @@
   +----------------------------------------------------------------------+
 */

-#ifndef ZEND_HASH_H
-#define ZEND_HASH_H
+#ifndef _HASH_
+#define _HASH_

 #include <sys/types.h>

@@ -29,58 +29,46 @@
 #define HASH_UPDATE 		(1<<0)
 #define HASH_ADD			(1<<1)
 #define HASH_NEXT_INSERT	(1<<2)
+#define HASH_ADD_PTR		(1<<3)

 #define HASH_DEL_KEY 0
 #define HASH_DEL_INDEX 1

-typedef int  (*compare_func_t)(const void *, const void *);
-typedef void (*sort_func_t)(void *, size_t, register size_t, compare_func_t);
-typedef void (*dtor_func_t)(void *pDest);
-typedef int (*apply_func_t)(void *pDest);
-typedef int (*apply_func_arg_t)(void *pDest, void *argument);
-typedef ulong (*hash_func_t)(char *arKey, uint nKeyLength);
-typedef void (*copy_ctor_func_t)(void *pElement);
-
-struct _hashtable;
+struct hashtable;

 typedef struct bucket {
 	ulong h;						/* Used for numeric indexing */
 	uint nKeyLength;
 	void *pData;
 	void *pDataPtr;
+	char bIsPointer;
 	struct bucket *pListNext;
 	struct bucket *pListLast;
 	struct bucket *pNext;
-	struct bucket *pLast;
 	char arKey[1]; /* Must be last element */
 } Bucket;

-typedef struct _hashtable {
+typedef struct hashtable {
 	uint nTableSize;
 	uint nHashSizeIndex;
 	uint nNumOfElements;
 	ulong nNextFreeElement;
-	hash_func_t pHashFunction;
+	ulong(*pHashFunction) (char *arKey, uint nKeyLength);
 	Bucket *pInternalPointer;	/* Used for element traversal */
 	Bucket *pListHead;
 	Bucket *pListTail;
 	Bucket **arBuckets;
-	dtor_func_t pDestructor;
-	zend_bool persistent;
-	unsigned char nApplyCount;
-	zend_bool bApplyProtection;
-#if ZEND_DEBUG
-	int inconsistent;
-#endif
+	int (*pDestructor) (void *pData);
+	unsigned char persistent;
 } HashTable;

-typedef Bucket* HashPosition;
+typedef int  (*compare_func_t) (const void *, const void *);
+typedef void (*sort_func_t) (void *, size_t, register size_t, compare_func_t);

 BEGIN_EXTERN_C()

 /* startup/shutdown */
-ZEND_API int zend_hash_init(HashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, int persistent);
-ZEND_API int zend_hash_init_ex(HashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, int persistent, zend_bool bApplyProtection);
+ZEND_API int zend_hash_init(HashTable *ht, uint nSize, ulong(*pHashFunction) (char *arKey, uint nKeyLength), int (*pDestructor) (void *pData), int persistent);
 ZEND_API void zend_hash_destroy(HashTable *ht);

 ZEND_API void zend_hash_clean(HashTable *ht);
@@ -91,18 +79,27 @@ ZEND_API int zend_hash_add_or_update(HashTable *ht, char *arKey, uint nKeyLength
 		zend_hash_add_or_update(ht,arKey,nKeyLength,pData,nDataSize,pDest,HASH_UPDATE)
 #define zend_hash_add(ht,arKey,nKeyLength,pData,nDataSize,pDest) \
 		zend_hash_add_or_update(ht,arKey,nKeyLength,pData,nDataSize,pDest,HASH_ADD)
+#define zend_hash_update_ptr(ht,arKey,nKeyLength,pData,nDataSize,pDest) \
+		zend_hash_add_or_update(ht,arKey,nKeyLength,pData,0,pDest,(HASH_UPDATE|HASH_ADD_PTR))

 ZEND_API int zend_hash_quick_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest,int flag);
 #define zend_hash_quick_update(ht,arKey,nKeyLength,h,pData,nDataSize,pDest) \
 		zend_hash_quick_add_or_update(ht,arKey,nKeyLength,h,pData,nDataSize,pDest,HASH_UPDATE)
 #define zend_hash_quick_add(ht,arKey,nKeyLength,h,pData,nDataSize,pDest) \
 		zend_hash_quick_add_or_update(ht,arKey,nKeyLength,h,pData,nDataSize,pDest,HASH_ADD)
+#define zend_hash_quick_update_ptr(ht,arKey,nKeyLength,h,pData,nDataSize,pDest) \
+		zend_hash_quick_add_or_update(ht,arKey,nKeyLength,h,pData,0,pDest,HASH_UPDATE|HASH_ADD_PTR)

 ZEND_API int zend_hash_index_update_or_next_insert(HashTable *ht, ulong h, void *pData, uint nDataSize, void **pDest, int flag);
 #define zend_hash_index_update(ht,h,pData,nDataSize,pDest) \
 		zend_hash_index_update_or_next_insert(ht,h,pData,nDataSize,pDest,HASH_UPDATE)
 #define zend_hash_next_index_insert(ht,pData,nDataSize,pDest) \
 		zend_hash_index_update_or_next_insert(ht,0,pData,nDataSize,pDest,HASH_NEXT_INSERT)
+#define zend_hash_next_index_insert_ptr(ht,pData,nDataSize,pDest) \
+		zend_hash_index_update_or_next_insert(ht,0,pData,nDataSize,pDest,HASH_NEXT_INSERT|HASH_ADD_PTR)
+
+ZEND_API int zend_hash_pointer_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData);
+

 typedef struct _zend_hash_key {
 	char *arKey;
@@ -111,14 +108,16 @@ typedef struct _zend_hash_key {
 } zend_hash_key;


-typedef int (*apply_func_args_t)(void *pDest, int num_args, va_list args, zend_hash_key *hash_key);
-
 #define ZEND_STD_HASH_APPLIER		\
 	int (*)(void *element, int num_args, va_list args, zend_hash_key *hash_key)

-ZEND_API void zend_hash_graceful_destroy(HashTable *ht);
-ZEND_API void zend_hash_apply(HashTable *ht, apply_func_t apply_func);
-ZEND_API void zend_hash_apply_with_argument(HashTable *ht, apply_func_arg_t apply_func, void *);
+ZEND_API int zend_hash_pointer_index_update_or_next_insert(HashTable *ht, ulong h, void *pData, int flag);
+#define zend_hash_pointer_index_update(ht,h,pData) \
+		zend_hash_pointer_index_update_or_next_insert(ht,h,pData,HASH_UPDATE)
+#define zend_hash_next_index_pointer_insert(ht,pData) \
+        zend_hash_pointer_index_update_or_next_insert(ht,0,pData,HASH_NEXT_INSERT)
+ZEND_API void zend_hash_apply(HashTable *ht,int (*destruct)(void *));
+ZEND_API void zend_hash_apply_with_argument(HashTable *ht,int (*destruct)(void *, void *), void *);
 ZEND_API void zend_hash_apply_with_arguments(HashTable *ht, ZEND_STD_HASH_APPLIER, int, ...);


@@ -141,39 +140,24 @@ ZEND_API int zend_hash_index_find(HashTable *ht, ulong h, void **pData);
 /* Misc */
 ZEND_API int zend_hash_exists(HashTable *ht, char *arKey, uint nKeyLength);
 ZEND_API int zend_hash_index_exists(HashTable *ht, ulong h);
+ZEND_API int zend_hash_is_pointer(HashTable *ht, char *arKey, uint nKeyLength);
+ZEND_API int zend_hash_index_is_pointer(HashTable *ht, ulong h);
 ZEND_API ulong zend_hash_next_free_element(HashTable *ht);

 /* traversing */
-ZEND_API int zend_hash_move_forward_ex(HashTable *ht, HashPosition *pos);
-ZEND_API int zend_hash_move_backwards_ex(HashTable *ht, HashPosition *pos);
-ZEND_API int zend_hash_get_current_key_ex(HashTable *ht, char **str_index, ulong *str_length, ulong *num_index, HashPosition *pos);
-ZEND_API int zend_hash_get_current_key_type_ex(HashTable *ht, HashPosition *pos);
-ZEND_API int zend_hash_get_current_data_ex(HashTable *ht, void **pData, HashPosition *pos);
-ZEND_API void zend_hash_internal_pointer_reset_ex(HashTable *ht, HashPosition *pos);
-ZEND_API void zend_hash_internal_pointer_end_ex(HashTable *ht, HashPosition *pos);
-
-#define zend_hash_move_forward(ht) \
-	zend_hash_move_forward_ex(ht, NULL)
-#define zend_hash_move_backwards(ht) \
-	zend_hash_move_backwards_ex(ht, NULL)
-#define zend_hash_get_current_key(ht, str_index, num_index) \
-	zend_hash_get_current_key_ex(ht, str_index, NULL, num_index, NULL)
-#define zend_hash_get_current_key_type(ht) \
-	zend_hash_get_current_key_type_ex(ht, NULL)
-#define zend_hash_get_current_data(ht, pData) \
-	zend_hash_get_current_data_ex(ht, pData, NULL)
-#define zend_hash_internal_pointer_reset(ht) \
-	zend_hash_internal_pointer_reset_ex(ht, NULL)
-#define zend_hash_internal_pointer_end(ht) \
-	zend_hash_internal_pointer_end_ex(ht, NULL)
+ZEND_API void zend_hash_move_forward(HashTable *ht);
+ZEND_API void zend_hash_move_backwards(HashTable *ht);
+ZEND_API int zend_hash_get_current_key(HashTable *ht, char **str_index, ulong *num_index);
+ZEND_API int zend_hash_get_current_key_type(HashTable *ht);
+ZEND_API int zend_hash_get_current_data(HashTable *ht, void **pData);
+ZEND_API void zend_hash_internal_pointer_reset(HashTable *ht);
+ZEND_API void zend_hash_internal_pointer_end(HashTable *ht);

 /* Copying, merging and sorting */
-ZEND_API void zend_hash_copy(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size);
-ZEND_API void zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size, int overwrite);
-ZEND_API void zend_hash_merge_ex(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, uint size, zend_bool (*pReplaceOrig)(void *orig, void *p_new));
+ZEND_API void zend_hash_copy(HashTable *target, HashTable *source, void (*pCopyConstructor) (void *pData), void *tmp, uint size);
+ZEND_API void zend_hash_merge(HashTable *target, HashTable *source, void (*pCopyConstructor) (void *pData), void *tmp, uint size, int overwrite);
 ZEND_API int zend_hash_sort(HashTable *ht, sort_func_t sort_func, compare_func_t compare_func, int renumber);
-ZEND_API int zend_hash_compare(HashTable *ht1, HashTable *ht2, compare_func_t compar, zend_bool ordered);
-ZEND_API int zend_hash_minmax(HashTable *ht, int (*compar)(const void *, const void *), int flag, void **pData);
+ZEND_API int zend_hash_minmax(HashTable *ht, int (*compar) (const void *, const void *), int flag, void **pData);

 ZEND_API int zend_hash_num_elements(HashTable *ht);

@@ -181,7 +165,7 @@ ZEND_API int zend_hash_rehash(HashTable *ht);

 ZEND_API ulong hashpjw(char *arKey, uint nKeyLength);

-#if ZEND_DEBUG
+#if DEBUG
 /* debug */
 void zend_hash_display_pListTail(HashTable *ht);
 void zend_hash_display(HashTable *ht);
@@ -189,11 +173,4 @@ void zend_hash_display(HashTable *ht);

 END_EXTERN_C()

-#define ZEND_INIT_SYMTABLE(ht)								\
-	ZEND_INIT_SYMTABLE_EX(ht, 2, 0)
-
-#define ZEND_INIT_SYMTABLE_EX(ht, n, persistent)			\
-	zend_hash_init(ht, n, NULL, ZVAL_PTR_DTOR, persistent)
-
-
-#endif							/* ZEND_HASH_H */
+#endif							/* _HASH_ */
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -19,7 +19,6 @@


 #include "zend.h"
-#include "zend_language_parser.h"
 #include "zend_compile.h"
 #include "zend_highlight.h"
 #include "zend_ptr_stack.h"
@@ -33,7 +32,7 @@ extern int zendleng;
 #define zendleng zend_get_zendleng(CLS_C)
 #endif

-ZEND_API void zend_html_putc(char c)
+static void html_putc(char c)
 {
 	switch (c) {
 		case '\n':
@@ -61,12 +60,12 @@ ZEND_API void zend_html_putc(char c)
 }


-ZEND_API void zend_html_puts(char *s, uint len)
+static void html_puts(char *s, uint len)
 {
 	register char *ptr=s, *end=s+len;
 	
 	while (ptr<end) {
-		zend_html_putc(*ptr++);
+		html_putc(*ptr++);
 	}
 }

@@ -81,7 +80,6 @@ ZEND_API void zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini
 	int in_string=0;
 	CLS_FETCH();

-	zend_printf("<code>");
 	zend_printf("<font color=\"%s\">\n", last_color);
 	/* highlight stuff coming back from zendlex() */
 	token.type = 0;
@@ -94,7 +92,6 @@ ZEND_API void zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini
 				next_color = syntax_highlighter_ini->highlight_comment;
 				break;
 			case T_OPEN_TAG:
-			case T_OPEN_TAG_WITH_ECHO:
 				next_color = syntax_highlighter_ini->highlight_default;
 				break;
 			case T_CLOSE_TAG:
@@ -108,7 +105,7 @@ ZEND_API void zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini
 				in_string = !in_string;
 				break;				
 			case T_WHITESPACE:
-				zend_html_puts(zendtext, zendleng);  /* no color needed */
+				html_puts(zendtext, zendleng);  /* no color needed */
 				token.type = 0;
 				continue;
 				break;
@@ -135,18 +132,17 @@ ZEND_API void zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini
 			}
 		}
 		switch (token_type) {
-			case T_END_HEREDOC:
-				zend_html_puts(token.value.str.val, token.value.str.len);
+			case T_DOLLAR_OPEN_CURLY_BRACES:
+				html_puts("{", 1);
 				break;
 			default:
-				zend_html_puts(zendtext, zendleng);
+				html_puts(zendtext, zendleng);
 				break;
 		}

 		if (token.type == IS_STRING) {
 			switch (token_type) {
 				case T_OPEN_TAG:
-				case T_OPEN_TAG_WITH_ECHO:
 				case T_CLOSE_TAG:
 				case T_WHITESPACE:
 					break;
@@ -154,14 +150,6 @@ ZEND_API void zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini
 					efree(token.value.str.val);
 					break;
 			}
-		} else if (token_type == T_END_HEREDOC) {
-			zend_bool has_semicolon=(strchr(token.value.str.val, ';')?1:0);
-
-			efree(token.value.str.val);
-			if (has_semicolon) {
-				/* the following semicolon was unput(), ignore it */
-				lex_scan(&token CLS_CC);
-			}
 		}
 		token.type = 0;
 	}
@@ -169,7 +157,6 @@ ZEND_API void zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini
 		zend_printf("</font>\n");
 	}
 	zend_printf("</font>\n");
-	zend_printf("</code>");
 }

 /*
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -18,8 +18,8 @@
 */


-#ifndef ZEND_HIGHLIGHT_H
-#define ZEND_HIGHLIGHT_H
+#ifndef _HIGHLIGHT_H
+#define _HIGHLIGHT_H

 #define HL_COMMENT_COLOR     "#FF8000"    /* orange */
 #define HL_DEFAULT_COLOR     "#0000BB"    /* blue */
@@ -40,10 +40,8 @@ typedef struct _zend_syntax_highlighter_ini {

 BEGIN_EXTERN_C()
 ZEND_API void zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini);
-ZEND_API int highlight_file(char *filename, zend_syntax_highlighter_ini *syntax_highlighter_ini);
-ZEND_API int highlight_string(zval *str, zend_syntax_highlighter_ini *syntax_highlighter_ini, char *str_name);
-ZEND_API void zend_html_putc(char c);
-ZEND_API void zend_html_puts(char *s, uint len);
+int highlight_file(char *filename, zend_syntax_highlighter_ini *syntax_highlighter_ini);
+int highlight_string(zval *str, zend_syntax_highlighter_ini *syntax_highlighter_ini);
 END_EXTERN_C()

 extern zend_syntax_highlighter_ini syntax_highlighter_ini;
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -22,7 +22,6 @@


 #include "zend.h"
-#include "zend_language_parser.h"
 #include "zend_compile.h"
 #include "zend_indent.h"

@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -18,9 +18,9 @@
 */


-#ifndef ZEND_INDENT_H
-#define ZEND_INDENT_H
+#ifndef _ZEND_INDENT_H
+#define _ZEND_INDENT_H

-ZEND_API void zend_indent(void);
+ZEND_API void zend_indent();

-#endif /* ZEND_INDENT_H */
+#endif /* _ZEND_INDENT_H */
@@ -1,485 +0,0 @@
-/*
-   +----------------------------------------------------------------------+
-   | Zend Engine                                                          |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
-   | that is bundled with this package in the file LICENSE, and is        |
-   | available at through the world-wide-web at                           |
-   | http://www.zend.com/license/0_92.txt.                                |
-   | If you did not receive a copy of the Zend license and are unable to  |
-   | obtain it through the world-wide-web, please send a note to          |
-   | license@zend.com so we can mail you a copy immediately.              |
-   +----------------------------------------------------------------------+
-   | Author: Zeev Suraski <zeev@zend.com>                                 |
-   +----------------------------------------------------------------------+
-*/
-
-
-#include <stdlib.h>
-
-#include "zend.h"
-#include "zend_API.h"
-#include "zend_ini.h"
-#include "zend_alloc.h"
-#include "zend_operators.h"
-
-static HashTable known_directives;
-
-
-/*
- * hash_apply functions
- */
-static int zend_remove_ini_entries(zend_ini_entry *ini_entry, int *module_number)
-{
-	if (ini_entry->module_number == *module_number) {
-		return 1;
-	} else {
-		return 0;
-	}
-}
-
-
-static int zend_restore_ini_entry_cb(zend_ini_entry *ini_entry, int stage)
-{
-	if (ini_entry->modified) {
-		if (ini_entry->on_modify) {
-			ini_entry->on_modify(ini_entry, ini_entry->orig_value, ini_entry->orig_value_length, ini_entry->mh_arg1, ini_entry->mh_arg2, ini_entry->mh_arg3, stage);
-		}
-		efree(ini_entry->value);
-		ini_entry->value = ini_entry->orig_value;
-		ini_entry->value_length = ini_entry->orig_value_length;
-		ini_entry->modified = 0;
-		ini_entry->orig_value = NULL;
-		ini_entry->orig_value_length = 0;
-	}
-	return 0;
-}
-
-/*
- * Startup / shutdown
- */
-int zend_ini_mstartup()
-{
-	if (zend_hash_init_ex(&known_directives, 100, NULL, NULL, 1, 0)==FAILURE) {
-		return FAILURE;
-	}
-	return SUCCESS;
-}
-
-
-int zend_ini_mshutdown()
-{
-	zend_hash_destroy(&known_directives);
-	return SUCCESS;
-}
-
-
-int zend_ini_rshutdown()
-{
-	zend_hash_apply_with_argument(&known_directives, (int (*)(void *, void *)) zend_restore_ini_entry_cb, (void *) ZEND_INI_STAGE_DEACTIVATE);
-	return SUCCESS;
-}
-
-
-static int ini_key_compare(const void *a, const void *b)
-{
-	Bucket *f;
-	Bucket *s;
- 
-	f = *((Bucket **) a);
-	s = *((Bucket **) b);
-
-	if (f->nKeyLength==0 && s->nKeyLength==0) { /* both numeric */
-		return ZEND_NORMALIZE_BOOL(f->nKeyLength - s->nKeyLength);
-	} else if (f->nKeyLength==0) { /* f is numeric, s is not */
-		return -1;
-	} else if (s->nKeyLength==0) { /* s is numeric, f is not */
-		return 1;
-	} else { /* both strings */
-		return zend_binary_strcasecmp(f->arKey, f->nKeyLength, s->arKey, s->nKeyLength);
-	}
-}
-
-
-void zend_ini_sort_entries(void)
-{
-	zend_hash_sort(&known_directives, qsort, ini_key_compare, 0);
-}
-
-/*
- * Registration / unregistration
- */
-
-ZEND_API int zend_register_ini_entries(zend_ini_entry *ini_entry, int module_number)
-{
-	zend_ini_entry *p = ini_entry;
-	zend_ini_entry *hashed_ini_entry;
-	zval *default_value;
-
-	while (p->name) {
-		p->module_number = module_number;
-		if (zend_hash_add(&known_directives, p->name, p->name_length, p, sizeof(zend_ini_entry), (void **) &hashed_ini_entry)==FAILURE) {
-			zend_unregister_ini_entries(module_number);
-			return FAILURE;
-		}
-		if ((default_value=cfg_get_entry(p->name, p->name_length))) {
-			if (!hashed_ini_entry->on_modify
-				|| hashed_ini_entry->on_modify(hashed_ini_entry, default_value->value.str.val, default_value->value.str.len, hashed_ini_entry->mh_arg1, hashed_ini_entry->mh_arg2, hashed_ini_entry->mh_arg3, ZEND_INI_STAGE_STARTUP)==SUCCESS) {
-				hashed_ini_entry->value = default_value->value.str.val;
-				hashed_ini_entry->value_length = default_value->value.str.len;
-			}
-		} else {
-			if (hashed_ini_entry->on_modify) {
-				hashed_ini_entry->on_modify(hashed_ini_entry, hashed_ini_entry->value, hashed_ini_entry->value_length, hashed_ini_entry->mh_arg1, hashed_ini_entry->mh_arg2, hashed_ini_entry->mh_arg3, ZEND_INI_STAGE_STARTUP);
-			}
-		}
-		p++;
-	}
-	return SUCCESS;
-}
-
-
-ZEND_API void zend_unregister_ini_entries(int module_number)
-{
-	zend_hash_apply_with_argument(&known_directives, (int (*)(void *, void *)) zend_remove_ini_entries, (void *) &module_number);
-}
-
-
-static int zend_ini_refresh_cache(zend_ini_entry *p, int stage)
-{
-	if (p->on_modify) {
-		p->on_modify(p, p->value, p->value_length, p->mh_arg1, p->mh_arg2, p->mh_arg3, stage);
-	}
-	return 0;
-}
-
-
-ZEND_API void zend_ini_refresh_caches(int stage)
-{
-	zend_hash_apply_with_argument(&known_directives, (int (*)(void *, void *)) zend_ini_refresh_cache, (void *)(long) stage);
-}
-
-
-ZEND_API int zend_alter_ini_entry(char *name, uint name_length, char *new_value, uint new_value_length, int modify_type, int stage)
-{
-	zend_ini_entry *ini_entry;
-	char *duplicate;
-
-	if (zend_hash_find(&known_directives, name, name_length, (void **) &ini_entry)==FAILURE) {
-		return FAILURE;
-	}
-
-	if (!(ini_entry->modifyable & modify_type)) {
-		return FAILURE;
-	}
-
-	duplicate = estrndup(new_value, new_value_length);
-	
-	if (!ini_entry->on_modify
-		|| ini_entry->on_modify(ini_entry, duplicate, new_value_length, ini_entry->mh_arg1, ini_entry->mh_arg2, ini_entry->mh_arg3, stage)==SUCCESS) {
-		if (!ini_entry->modified) {
-			ini_entry->orig_value = ini_entry->value;
-			ini_entry->orig_value_length = ini_entry->value_length;
-		} else { /* we already changed the value, free the changed value */
-			efree(ini_entry->value);
-		}
-		ini_entry->value = duplicate;
-		ini_entry->value_length = new_value_length;
-		ini_entry->modified = 1;
-	} else {
-		efree(duplicate);
-	}
-
-	return SUCCESS;
-}
-
-
-ZEND_API int zend_restore_ini_entry(char *name, uint name_length, int stage)
-{
-	zend_ini_entry *ini_entry;
-
-	if (zend_hash_find(&known_directives, name, name_length, (void **) &ini_entry)==FAILURE) {
-		return FAILURE;
-	}
-
-	zend_restore_ini_entry_cb(ini_entry, stage);
-	return SUCCESS;
-}
-
-
-ZEND_API int zend_ini_register_displayer(char *name, uint name_length, void (*displayer)(zend_ini_entry *ini_entry, int type))
-{
-	zend_ini_entry *ini_entry;
-
-	if (zend_hash_find(&known_directives, name, name_length, (void **) &ini_entry)==FAILURE) {
-		return FAILURE;
-	}
-
-	ini_entry->displayer = displayer;
-	return SUCCESS;
-}
-
-
-
-/*
- * Data retrieval
- */
-
-ZEND_API long zend_ini_long(char *name, uint name_length, int orig)
-{
-	zend_ini_entry *ini_entry;
-
-	if (zend_hash_find(&known_directives, name, name_length, (void **) &ini_entry)==SUCCESS) {
-		if (orig && ini_entry->modified) {
-			return (ini_entry->orig_value ? strtol(ini_entry->orig_value, NULL, 0) : 0);
-		} else if (ini_entry->value) {
-			return strtol(ini_entry->value, NULL, 0);
-		}
-	}
-
-	return 0;
-}
-
-
-ZEND_API double zend_ini_double(char *name, uint name_length, int orig)
-{
-	zend_ini_entry *ini_entry;
-
-	if (zend_hash_find(&known_directives, name, name_length, (void **) &ini_entry)==SUCCESS) {
-		if (orig && ini_entry->modified) {
-			return (double) (ini_entry->orig_value ? strtod(ini_entry->orig_value, NULL) : 0.0);
-		} else if (ini_entry->value) {
-			return (double) strtod(ini_entry->value, NULL);
-		}
-	}
-
-	return 0.0;
-}
-
-
-ZEND_API char *zend_ini_string(char *name, uint name_length, int orig)
-{
-	zend_ini_entry *ini_entry;
-
-	if (zend_hash_find(&known_directives, name, name_length, (void **) &ini_entry)==SUCCESS) {
-		if (orig && ini_entry->modified) {
-			return ini_entry->orig_value;
-		} else {
-			return ini_entry->value;
-		}
-	}
-
-	return "";
-}
-
-
-zend_ini_entry *get_ini_entry(char *name, uint name_length)
-{
-	zend_ini_entry *ini_entry;
-
-	if (zend_hash_find(&known_directives, name, name_length, (void **) &ini_entry)==SUCCESS) {
-		return ini_entry;
-	} else {
-		return NULL;
-	}
-}
-
-
-static void zend_ini_displayer_cb(zend_ini_entry *ini_entry, int type)
-{
-	if (ini_entry->displayer) {
-		ini_entry->displayer(ini_entry, type);
-	} else {
-		char *display_string;
-		uint display_string_length;
-
-		if (type==ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
-			if (ini_entry->orig_value) {
-				display_string = ini_entry->orig_value;
-				display_string_length = ini_entry->orig_value_length;
-			} else {
-				display_string = "<i>no value</i>";
-				display_string_length = sizeof("<i>no value</i>")-1;
-			}
-		} else if (ini_entry->value && ini_entry->value[0]) {
-			display_string = ini_entry->value;
-			display_string_length = ini_entry->value_length;
-		} else {
-			display_string = "<i>no value</i>";
-			display_string_length = sizeof("<i>no value</i>")-1;
-		}
-		ZEND_WRITE(display_string, display_string_length);
-	}
-}
-
-
-ZEND_INI_DISP(zend_ini_boolean_displayer_cb)
-{
-	int value;
-
-	if (type==ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
-		value = (ini_entry->orig_value ? atoi(ini_entry->orig_value) : 0);
-	} else if (ini_entry->value) {
-		value = atoi(ini_entry->value);
-	} else {
-		value = 0;
-	}
-	if (value) {
-		ZEND_PUTS("On");
-	} else {
-		ZEND_PUTS("Off");
-	}
-}
-
-
-ZEND_INI_DISP(zend_ini_color_displayer_cb)
-{
-	char *value;
-
-	if (type==ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
-		value = ini_entry->orig_value;
-	} else if (ini_entry->value) {
-		value = ini_entry->value;
-	} else {
-		value = NULL;
-	}
-	if (value) {
-		zend_printf("<font color=\"%s\">%s</font>", value, value);
-	} else {
-		ZEND_PUTS("<i>no value</i>;");
-	}
-}
-
-
-ZEND_INI_DISP(display_link_numbers)
-{
-	char *value;
-
-	if (type==ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
-		value = ini_entry->orig_value;
-	} else if (ini_entry->value) {
-		value = ini_entry->value;
-	} else {
-		value = NULL;
-	}
-
-	if (value) {
-		if (atoi(value)==-1) {
-			ZEND_PUTS("Unlimited");
-		} else {
-			zend_printf("%s", value);
-		}
-	}
-}
-
-
-ZEND_API void zend_ini_apply_with_argument(apply_func_arg_t apply_func, void *arg)
-{
-	zend_hash_apply_with_argument(&known_directives, apply_func, arg);
-}
-
-
-/* Standard message handlers */
-
-ZEND_API ZEND_INI_MH(OnUpdateBool)
-{
-	zend_bool *p;
-#ifndef ZTS
-	char *base = (char *) mh_arg2;
-#else
-	char *base;
-
-	base = (char *) ts_resource(*((int *) mh_arg2));
-#endif
-
-	p = (zend_bool *) (base+(size_t) mh_arg1);
-
-	*p = (zend_bool) atoi(new_value);
-	return SUCCESS;
-}
-
-
-ZEND_API ZEND_INI_MH(OnUpdateInt)
-{
-	long *p;
-#ifndef ZTS
-	char *base = (char *) mh_arg2;
-#else
-	char *base;
-
-	base = (char *) ts_resource(*((int *) mh_arg2));
-#endif
-
-	p = (long *) (base+(size_t) mh_arg1);
-
-	*p = zend_atoi(new_value, new_value_length);
-	return SUCCESS;
-}
-
-
-ZEND_API ZEND_INI_MH(OnUpdateReal)
-{
-	double *p;
-#ifndef ZTS
-	char *base = (char *) mh_arg2;
-#else
-	char *base;
-
-	base = (char *) ts_resource(*((int *) mh_arg2));
-#endif
-
-	p = (double *) (base+(size_t) mh_arg1);
-
-	*p = strtod(new_value, NULL);
-	return SUCCESS;
-}
-
-
-ZEND_API ZEND_INI_MH(OnUpdateString)
-{
-	char **p;
-#ifndef ZTS
-	char *base = (char *) mh_arg2;
-#else
-	char *base;
-
-	base = (char *) ts_resource(*((int *) mh_arg2));
-#endif
-
-	p = (char **) (base+(size_t) mh_arg1);
-
-	*p = new_value;
-	return SUCCESS;
-}
-
-
-ZEND_API ZEND_INI_MH(OnUpdateStringUnempty)
-{
-	char **p;
-#ifndef ZTS
-	char *base = (char *) mh_arg2;
-#else
-	char *base;
-
-	base = (char *) ts_resource(*((int *) mh_arg2));
-#endif
-
-	if (new_value && !new_value[0]) {
-		return FAILURE;
-	}
-
-	p = (char **) (base+(size_t) mh_arg1);
-
-	*p = new_value;
-	return SUCCESS;
-}
-
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- */
@@ -1,168 +0,0 @@
-/*
-   +----------------------------------------------------------------------+
-   | Zend Engine                                                          |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
-   | that is bundled with this package in the file LICENSE, and is        |
-   | available at through the world-wide-web at                           |
-   | http://www.zend.com/license/0_92.txt.                                |
-   | If you did not receive a copy of the Zend license and are unable to  |
-   | obtain it through the world-wide-web, please send a note to          |
-   | license@zend.com so we can mail you a copy immediately.              |
-   +----------------------------------------------------------------------+
-   | Author: Zeev Suraski <zeev@zend.com>                                 |
-   +----------------------------------------------------------------------+
-*/
-
-
-#ifndef ZEND_INI_H
-#define ZEND_INI_H
-
-#define ZEND_INI_USER	(1<<0)
-#define ZEND_INI_PERDIR	(1<<1)
-#define ZEND_INI_SYSTEM	(1<<2)
-
-#define ZEND_INI_ALL (ZEND_INI_USER|ZEND_INI_PERDIR|ZEND_INI_SYSTEM)
-
-typedef struct _zend_ini_entry zend_ini_entry;
-
-#define ZEND_INI_MH(name) int name(zend_ini_entry *entry, char *new_value, uint new_value_length, void *mh_arg1, void *mh_arg2, void *mh_arg3, int stage)
-#define ZEND_INI_DISP(name) void name(zend_ini_entry *ini_entry, int type)
-
-struct _zend_ini_entry {
-	int module_number;
-	int modifyable;
-	char *name;
-	uint name_length;
-	ZEND_INI_MH((*on_modify));
-	void *mh_arg1;
-	void *mh_arg2;
-	void *mh_arg3;
-
-	char *value;
-	uint value_length;
-
-	char *orig_value;
-	uint orig_value_length;
-	int modified;
-
-	void (*displayer)(zend_ini_entry *ini_entry, int type);
-};
-
-
-int zend_ini_mstartup(void);
-int zend_ini_mshutdown(void);
-int zend_ini_rshutdown(void);
-
-void zend_ini_sort_entries(void);
-
-ZEND_API int zend_register_ini_entries(zend_ini_entry *ini_entry, int module_number);
-ZEND_API void zend_unregister_ini_entries(int module_number);
-ZEND_API void zend_ini_refresh_caches(int stage);
-ZEND_API int zend_alter_ini_entry(char *name, uint name_length, char *new_value, uint new_value_length, int modify_type, int stage);
-ZEND_API int zend_restore_ini_entry(char *name, uint name_length, int stage);
-ZEND_API void display_ini_entries(zend_module_entry *module);
-
-ZEND_API long zend_ini_long(char *name, uint name_length, int orig);
-ZEND_API double zend_ini_double(char *name, uint name_length, int orig);
-ZEND_API char *zend_ini_string(char *name, uint name_length, int orig);
-zend_ini_entry *get_ini_entry(char *name, uint name_length);
-
-ZEND_API int zend_ini_register_displayer(char *name, uint name_length, void (*displayer)(zend_ini_entry *ini_entry, int type));
-
-ZEND_API void zend_ini_apply_with_argument(apply_func_arg_t apply_func, void *arg);
-
-ZEND_API ZEND_INI_DISP(zend_ini_boolean_displayer_cb);
-ZEND_API ZEND_INI_DISP(zend_ini_color_displayer_cb);
-ZEND_API ZEND_INI_DISP(display_link_numbers);
-
-#define ZEND_INI_BEGIN()		static zend_ini_entry ini_entries[] = {
-#define ZEND_INI_END()		{ 0, 0, NULL, 0, NULL, NULL, NULL, NULL, NULL, 0, NULL, 0, 0, NULL } };
-
-#define ZEND_INI_ENTRY3_EX(name, default_value, modifyable, on_modify, arg1, arg2, arg3, displayer) \
-	{ 0, modifyable, name, sizeof(name), on_modify, arg1, arg2, arg3, default_value, sizeof(default_value)-1, NULL, 0, 0, displayer },
-
-#define ZEND_INI_ENTRY3(name, default_value, modifyable, on_modify, arg1, arg2, arg3) \
-	ZEND_INI_ENTRY3_EX(name, default_value, modifyable, on_modify, arg1, arg2, arg3, NULL)
-
-#define ZEND_INI_ENTRY2_EX(name, default_value, modifyable, on_modify, arg1, arg2, displayer) \
-	ZEND_INI_ENTRY3_EX(name, default_value, modifyable, on_modify, arg1, arg2, NULL, displayer)
-
-#define ZEND_INI_ENTRY2(name, default_value, modifyable, on_modify, arg1, arg2) \
-	ZEND_INI_ENTRY2_EX(name, default_value, modifyable, on_modify, arg1, arg2, NULL)
-
-#define ZEND_INI_ENTRY1_EX(name, default_value, modifyable, on_modify, arg1, displayer) \
-	ZEND_INI_ENTRY3_EX(name, default_value, modifyable, on_modify, arg1, NULL, NULL, displayer)
-
-#define ZEND_INI_ENTRY1(name, default_value, modifyable, on_modify, arg1) \
-	ZEND_INI_ENTRY1_EX(name, default_value, modifyable, on_modify, arg1, NULL)
-	
-#define ZEND_INI_ENTRY_EX(name, default_value, modifyable, on_modify, displayer) \
-	ZEND_INI_ENTRY3_EX(name, default_value, modifyable, on_modify, NULL, NULL, NULL, displayer)
-
-#define ZEND_INI_ENTRY(name, default_value, modifyable, on_modify) \
-	ZEND_INI_ENTRY_EX(name, default_value, modifyable, on_modify, NULL)
-
-#ifdef ZTS
-#define STD_ZEND_INI_ENTRY(name, default_value, modifyable, on_modify, property_name, struct_type, struct_ptr) \
-	ZEND_INI_ENTRY2(name, default_value, modifyable, on_modify, (void *) XtOffsetOf(struct_type, property_name), (void *) &struct_ptr##_id)
-#define STD_ZEND_INI_ENTRY_EX(name, default_value, modifyable, on_modify, property_name, struct_type, struct_ptr, displayer) \
-	ZEND_INI_ENTRY2_EX(name, default_value, modifyable, on_modify, (void *) XtOffsetOf(struct_type, property_name), (void *) &struct_ptr##_id, displayer)
-#define STD_ZEND_INI_BOOLEAN(name, default_value, modifyable, on_modify, property_name, struct_type, struct_ptr) \
-	ZEND_INI_ENTRY3_EX(name, default_value, modifyable, on_modify, (void *) XtOffsetOf(struct_type, property_name), (void *) &struct_ptr##_id, NULL, zend_ini_boolean_displayer_cb)
-#else
-#define STD_ZEND_INI_ENTRY(name, default_value, modifyable, on_modify, property_name, struct_type, struct_ptr) \
-	ZEND_INI_ENTRY2(name, default_value, modifyable, on_modify, (void *) XtOffsetOf(struct_type, property_name), (void *) &struct_ptr)
-#define STD_ZEND_INI_ENTRY_EX(name, default_value, modifyable, on_modify, property_name, struct_type, struct_ptr, displayer) \
-	ZEND_INI_ENTRY2_EX(name, default_value, modifyable, on_modify, (void *) XtOffsetOf(struct_type, property_name), (void *) &struct_ptr, displayer)
-#define STD_ZEND_INI_BOOLEAN(name, default_value, modifyable, on_modify, property_name, struct_type, struct_ptr) \
-	ZEND_INI_ENTRY3_EX(name, default_value, modifyable, on_modify, (void *) XtOffsetOf(struct_type, property_name), (void *) &struct_ptr, NULL, zend_ini_boolean_displayer_cb)
-#endif
-
-#define INI_INT(name) zend_ini_long((name), sizeof(name), 0)
-#define INI_FLT(name) zend_ini_double((name), sizeof(name), 0)
-#define INI_STR(name) zend_ini_string((name), sizeof(name), 0)
-#define INI_BOOL(name) ((zend_bool) INI_INT(name))
-
-#define INI_ORIG_INT(name)	zend_ini_long((name), sizeof(name), 1)
-#define INI_ORIG_FLT(name)	zend_ini_double((name), sizeof(name), 1)
-#define INI_ORIG_STR(name)	zend_ini_string((name), sizeof(name), 1)
-#define INI_ORIG_BOOL(name) ((zend_bool) INI_ORIG_INT(name))
-
-
-#define REGISTER_INI_ENTRIES() zend_register_ini_entries(ini_entries, module_number)
-#define UNREGISTER_INI_ENTRIES() zend_unregister_ini_entries(module_number)
-#define DISPLAY_INI_ENTRIES() display_ini_entries(zend_module)
-
-#define REGISTER_INI_DISPLAYER(name, displayer) zend_ini_register_displayer((name), sizeof(name), displayer)
-#define REGISTER_INI_BOOLEAN(name) REGISTER_INI_DISPLAYER(name, zend_ini_boolean_displayer_cb)
-
-zval *cfg_get_entry(char *name, uint name_length);
-
-
-/* Standard message handlers */
-ZEND_API ZEND_INI_MH(OnUpdateBool);
-ZEND_API ZEND_INI_MH(OnUpdateInt);
-ZEND_API ZEND_INI_MH(OnUpdateReal);
-ZEND_API ZEND_INI_MH(OnUpdateString);
-ZEND_API ZEND_INI_MH(OnUpdateStringUnempty);
-
-
-#define ZEND_INI_DISPLAY_ORIG	1
-#define ZEND_INI_DISPLAY_ACTIVE	2
-
-#define ZEND_INI_STAGE_STARTUP		(1<<0)
-#define ZEND_INI_STAGE_SHUTDOWN		(1<<1)
-#define ZEND_INI_STAGE_ACTIVATE		(1<<2)
-#define ZEND_INI_STAGE_DEACTIVATE	(1<<3)
-#define ZEND_INI_STAGE_RUNTIME		(1<<4)
-
-/* INI parsing engine */
-typedef void (*zend_ini_parser_cb_t)(zval *arg1, zval *arg2, int callback_type, void *arg);
-int zend_parse_ini_file(zend_file_handle *fh, zend_bool unbuffered_errors, zend_ini_parser_cb_t ini_parser_cb, void *arg);
-#define ZEND_INI_PARSER_ENTRY	1
-#define ZEND_INI_PARSER_SECTION	2
-
-#endif /* ZEND_INI_H */
@@ -1,231 +0,0 @@
-%{
-/*
-   +----------------------------------------------------------------------+
-   | Zend Engine                                                          |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
-   | that is bundled with this package in the file LICENSE, and is        |
-   | available at through the world-wide-web at                           |
-   | http://www.zend.com/license/0_92.txt.                                |
-   | If you did not receive a copy of the Zend license and are unable to  |
-   | obtain it through the world-wide-web, please send a note to          |
-   | license@zend.com so we can mail you a copy immediately.              |
-   +----------------------------------------------------------------------+
-   | Author: Zeev Suraski <zeev@zend.com>                                 |
-   +----------------------------------------------------------------------+
-*/
-
-
-/* $Id$ */
-
-#define DEBUG_CFG_PARSER 0
-#include "zend.h"
-#include "zend_API.h"
-#include "zend_ini.h"
-#include "zend_constants.h"
-#include "zend_ini_scanner.h"
-#include "zend_extensions.h"
-
-
-#if WIN32
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#include <winbase.h>
-#endif
-
-
-typedef struct _zend_ini_parser_param {
-	zend_ini_parser_cb_t ini_parser_cb;
-	void *arg;
-} zend_ini_parser_param;
-
-#define YYSTYPE zval
-#define YYPARSE_PARAM ini_parser_param
-
-#define ZEND_INI_PARSER_CB	((zend_ini_parser_param *) ini_parser_param)->ini_parser_cb
-#define ZEND_INI_PARSER_ARG	((zend_ini_parser_param *) ini_parser_param)->arg
-
-int ini_lex(zval *ini_lval);
-int ini_parse(void *ini_parser_param);
-
-zval yylval;
-
-#ifndef ZTS
-extern int ini_lex(zval *ini_lval);
-extern FILE *ini_in;
-extern int ini_lineno;
-extern void init_cfg_scanner(void);
-#endif
-
-void zend_ini_do_op(char type, zval *result, zval *op1, zval *op2)
-{
-	int i_result;
-	int i_op1, i_op2;
-	char str_result[MAX_LENGTH_OF_LONG];
-
-	i_op1 = atoi(op1->value.str.val);
-	free(op1->value.str.val);
-	if (op2) {
-		i_op2 = atoi(op2->value.str.val);
-		free(op2->value.str.val);
-	} else {
-		i_op2 = 0;
-	}
-
-	switch (type) {
-		case '|':
-			i_result = i_op1 | i_op2;
-			break;
-		case '&':
-			i_result = i_op1 & i_op2;
-			break;
-		case '~':
-			i_result = ~i_op1;
-			break;
-		case '!':
-			i_result = !i_op1;
-			break;
-		default:
-			i_result = 0;
-			break;
-	}
-
-	result->value.str.len = zend_sprintf(str_result, "%d", i_result);
-	result->value.str.val = (char *) malloc(result->value.str.len+1);
-	memcpy(result->value.str.val, str_result, result->value.str.len);
-	result->value.str.val[result->value.str.len] = 0;
-	result->type = IS_STRING;
-}
-
-
-void zend_ini_get_constant(zval *result, zval *name)
-{
-	zval z_constant;
-
-	if (zend_get_constant(name->value.str.val, name->value.str.len, &z_constant)) {
-		/* z_constant is emalloc()'d */
-		convert_to_string(&z_constant);
-		result->value.str.val = zend_strndup(z_constant.value.str.val, z_constant.value.str.len);
-		result->value.str.len = z_constant.value.str.len;
-		result->type = z_constant.type;
-		zval_dtor(&z_constant);
-		free(name->value.str.val);	
-	} else {
-		*result = *name;
-	}
-}
-
-
-static void ini_error(char *str)
-{
-	char *error_buf;
-	int error_buf_len;
-	char *currently_parsed_filename = zend_ini_scanner_get_filename();
-	CLS_FETCH();
-
-	error_buf_len = 128+strlen(currently_parsed_filename); /* should be more than enough */
-	error_buf = (char *) emalloc(error_buf_len);
-
-	sprintf(error_buf, "Error parsing %s on line %d\n", currently_parsed_filename, zend_ini_scanner_get_lineno());
-
-	if (CG(ini_parser_unbuffered_errors)) {
-#ifdef PHP_WIN32
-		MessageBox(NULL, error_buf, "PHP Error", MB_OK|MB_TOPMOST|0x00200000L);
-#else
-		fprintf(stderr, "PHP:  %s", error_buf);
-#endif
-	} else {
-		zend_error(E_CORE_WARNING, error_buf);
-	}
-	efree(error_buf);
-}
-
-
-int zend_parse_ini_file(zend_file_handle *fh, zend_bool unbuffered_errors, zend_ini_parser_cb_t ini_parser_cb, void *arg)
-{
-	zend_ini_parser_param ini_parser_param;
-	int retval;
-	CLS_FETCH();
-
-	ini_parser_param.ini_parser_cb = ini_parser_cb;
-	ini_parser_param.arg = arg;
-
-	if (zend_ini_open_file_for_scanning(fh)==FAILURE) {
-		return FAILURE;
-	}
-
-	CG(ini_parser_unbuffered_errors) = unbuffered_errors;
-	retval = ini_parse(&ini_parser_param);
-
-	zend_ini_close_file(fh);
-
-	if (retval==0) {
-		return SUCCESS;
-	} else {
-		return FAILURE;
-	}
-}
-
-
-%}
-
-%pure_parser
-%token TC_STRING
-%token TC_ENCAPSULATED_STRING
-%token SECTION
-%token CFG_TRUE
-%token CFG_FALSE
-%left '|' '&'
-%right '~' '!'
-
-%%
-
-statement_list:
-		statement_list statement
-	|	/* empty */
-;
-
-statement:
-		TC_STRING '=' string_or_value {
-#if DEBUG_CFG_PARSER
-			printf("'%s' = '%s'\n", $1.value.str.val, $3.value.str.val);
-#endif
-			ZEND_INI_PARSER_CB(&$1, &$3, ZEND_INI_PARSER_ENTRY, ZEND_INI_PARSER_ARG);
-			free($1.value.str.val);
-			free($3.value.str.val);
-		}
-	|	TC_STRING { ZEND_INI_PARSER_CB(&$1, NULL, ZEND_INI_PARSER_ENTRY, ZEND_INI_PARSER_ARG); free($1.value.str.val); }
-	|	SECTION { ZEND_INI_PARSER_CB(&$1, NULL, ZEND_INI_PARSER_SECTION, ZEND_INI_PARSER_ARG); free($1.value.str.val); }
-	|	'\n'
-;
-
-
-string_or_value:
-		expr { $$ = $1; }
-	|	TC_ENCAPSULATED_STRING { $$ = $1; }
-	|	CFG_TRUE { $$ = $1; }
-	|	CFG_FALSE { $$ = $1; }
-	|	'\n' { $$.value.str.val = strdup(""); $$.value.str.len=0; $$.type = IS_STRING; }
-	|	'\0' { $$.value.str.val = strdup(""); $$.value.str.len=0; $$.type = IS_STRING; }
-;
-
-expr:
-		constant_string			{ $$ = $1; }
-	|	expr '|' expr			{ zend_ini_do_op('|', &$$, &$1, &$3); }
-	|	expr '&' expr			{ zend_ini_do_op('&', &$$, &$1, &$3); }
-	|	'~' expr				{ zend_ini_do_op('~', &$$, &$2, NULL); }
-	|	'!'	expr				{ zend_ini_do_op('!', &$$, &$2, NULL); }
-	|	'(' expr ')'			{ $$ = $2; }
-;
-
-constant_string:
-		TC_STRING { zend_ini_get_constant(&$$, &$1); }
-;
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- */
@@ -1,24 +0,0 @@
-#ifndef _ZEND_INI_SCANNER_H
-#define _ZEND_INI_SCANNER_H
-
-#if defined(ZTS) && defined(__cplusplus)
-class ZendIniFlexLexer : public yyFlexLexer
-{
-public:
-	virtual ~ZendIniFlexLexer();
-	int lex_scan(zval *zendlval);
-	void BeginState(int state);
-
-	char *filename;
-};
-#endif	/* ZTS && __cplusplus */
-
-BEGIN_EXTERN_C()
-int zend_ini_scanner_get_lineno();
-char *zend_ini_scanner_get_filename();
-int zend_ini_open_file_for_scanning(zend_file_handle *fh);
-void zend_ini_close_file(zend_file_handle *fh);
-int ini_lex(zval *ini_lval);
-END_EXTERN_C()
-
-#endif /* _ZEND_INI_SCANNER_H */
@@ -1,283 +0,0 @@
-%{
-/*
-   +----------------------------------------------------------------------+
-   | Zend Engine                                                          |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
-   | that is bundled with this package in the file LICENSE, and is        |
-   | available at through the world-wide-web at                           |
-   | http://www.zend.com/license/0_92.txt.                                |
-   | If you did not receive a copy of the Zend license and are unable to  |
-   | obtain it through the world-wide-web, please send a note to          |
-   | license@zend.com so we can mail you a copy immediately.              |
-   +----------------------------------------------------------------------+
-   | Author: Zeev Suraski <zeev@zend.com>                                 |
-   +----------------------------------------------------------------------+
-*/
-
-#include "zend.h"
-#include "zend_globals.h"
-#include "zend_ini_parser.h"
-#include "zend_ini_scanner.h"
-
-#ifdef ZTS
-# ifdef HAVE_STDIOSTR_H
-#  include <stdiostr.h>
-# endif
-# ifdef HAVE_STDIOSTREAM_H
-#  include <stdiostream.h>
-# endif
-# ifdef ZEND_WIN32
-#  include <strstrea.h>
-# else
-#  include <strstream.h>
-# endif
-#endif
-
-#undef YYSTYPE
-#define YYSTYPE zval
-
-#ifdef ZTS
-#define YY_DECL int ZendIniFlexLexer::lex_scan(zval *ini_lval)
-#else
-#define YY_DECL int ini_lex(zval *ini_lval)
-#endif
-
-#ifndef ZTS
-static char *ini_filename;
-
-void init_ini_scanner()
-{
-	ini_lineno=1;
-}
-
-
-int zend_ini_scanner_get_lineno()
-{
-	return ini_lineno;
-}
-
-
-char *zend_ini_scanner_get_filename()
-{
-	return ini_filename;
-}
-
-#else /* ZTS */
-
-int zend_ini_scanner_get_lineno()
-{
-	CLS_FETCH();
-
-	return CG(ini_scanner)->lineno();
-}
-
-char *zend_ini_scanner_get_filename()
-{
-	CLS_FETCH();
-
-	return CG(ini_scanner)->filename;
-}
-
-int ini_lex(zval *ini_lval)
-{
-	CLS_FETCH();
-
-	return CG(ini_scanner)->lex_scan(ini_lval);
-}
-
-ZendIniFlexLexer::~ZendIniFlexLexer()
-{
-	if (yy_start_stack) {
-		yy_flex_free(yy_start_stack);
-	}
-}
-
-int yyFlexLexer::yylex()
-{
-	fprintf(stderr, "Error:  yyFlexLexer::yylex() called\n");
-	return -1;
-}
-
-#endif
-
-
-int zend_ini_open_file_for_scanning(zend_file_handle *fh)
-{
-	FILE *fp;
-	CLS_FETCH();
-
-	switch (fh->type) {
-		case ZEND_HANDLE_FP:
-			fp = fh->handle.fp;
-			break;
-		case ZEND_HANDLE_FILENAME:
-			fp = zend_fopen(fh->filename, NULL);
-			fh->type = ZEND_HANDLE_FP;
-			break;
-		default:
-			return FAILURE;
-	}
-
-#ifdef ZTS
-	if (!fp) {
-		return FAILURE;
-	}
-	fh->handle.is = new istdiostream(fp);
-	fh->type = ZEND_HANDLE_STDIOSTREAM;
-
-	CG(ini_scanner) = new ZendIniFlexLexer;
-	CG(ini_scanner)->switch_streams(fh->handle.is, &cout);
-	CG(ini_scanner)->filename = fh->filename;
-#else
-	init_ini_scanner();
-	yyin = fp;
-	yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
-	ini_filename = fh->filename;
-#endif
-	return SUCCESS;
-}
-
-
-void zend_ini_close_file(zend_file_handle *fh)
-{
-	switch (fh->type) {
-		case ZEND_HANDLE_FP:
-			fclose(fh->handle.fp);
-			break;
-#ifdef ZTS
-		case ZEND_HANDLE_STDIOSTREAM: {
-				CLS_FETCH();
-				delete CG(ini_scanner);
-			}
-			break;
-#endif
-	}
-}
-
-%}
-
-%option noyywrap
-%option yylineno
-
-%%
-
-
-<INITIAL>[ ]*("true"|"on"|"yes")[ ]* {
-	ini_lval->value.str.val = zend_strndup("1",1);
-	ini_lval->value.str.len = 1;
-	ini_lval->type = IS_STRING;
-	return CFG_TRUE;
-}
-
-
-<INITIAL>[ ]*("false"|"off"|"no"|"none")[ ]* {
-	ini_lval->value.str.val = zend_strndup("",0);
-	ini_lval->value.str.len = 0;
-	ini_lval->type = IS_STRING;
-	return CFG_FALSE;
-}
-
-<INITIAL>[[][^[]+[\]]([\n]?|"\r\n"?) {
-	/* SECTION */
-
-	/* eat trailng ] */
-	while (yyleng>0 && (yytext[yyleng-1]=='\n' || yytext[yyleng-1]=='\r' || yytext[yyleng-1]==']')) {
-		yyleng--;
-		yytext[yyleng]=0;
-	}
-
-	/* eat leading [ */
-	yytext++;
-	yyleng--;
-
-	ini_lval->value.str.val = zend_strndup(yytext,yyleng);
-	ini_lval->value.str.len = yyleng;
-	ini_lval->type = IS_STRING;
-	return SECTION;
-}
-
-
-<INITIAL>["][^\n\r"]*["] {
-	/* ENCAPSULATED TC_STRING */
-
-	/* eat trailing " */
-	yytext[yyleng-1]=0;
-	
-	/* eat leading " */
-	yytext++;
-
-	ini_lval->value.str.val = zend_strndup(yytext, yyleng - 2);
-	ini_lval->value.str.len = yyleng - 2;
-	ini_lval->type = IS_STRING;
-	return TC_ENCAPSULATED_STRING;
-}
-
-<INITIAL>[&|~()!] {
-	return yytext[0];
-}
-
-
-<INITIAL>[^=\n\r\t;|&~()!"]+ {
-	/* STRING */
-	register int i;
-
-	/* eat trailing whitespace */
-	for (i=yyleng-1; i>=0; i--) {
-		if (yytext[i]==' ' || yytext[i]=='\t') {
-			yytext[i]=0;
-			yyleng--;
-		} else {
-			break;
-		}
-	}
-	/* eat leading whitespace */
-	while (yytext[0]) {
-		if (yytext[0]==' ' || yytext[0]=='\t') {
-			yytext++;
-			yyleng--;
-		} else {
-			break;
-		}
-	}
-	if (yyleng!=0) {
-		ini_lval->value.str.val = zend_strndup(yytext,yyleng);
-		ini_lval->value.str.len = yyleng;
-		ini_lval->type = IS_STRING;
-		return TC_STRING;
-	} else {
-		/* whitespace */
-	}
-}
-
-
-
-<INITIAL>[=\n] {
-	return yytext[0];
-}
-
-<INITIAL>"\r\n" {
-	return '\n';
-}
-
-<INITIAL>[;][^\r\n]*[\r\n]? {
-	/* comment */
-	return '\n';
-}
-
-<INITIAL>[ \t] {
-	/* eat whitespace */
-}
-
-<INITIAL>. {
-#if DEBUG
-	php_error(E_NOTICE,"Unexpected character on line %d:  '%s' (ASCII %d)\n",yylineno,yytext,yytext[0]);
-#endif
-}
-
-<<EOF>> {
-	yy_delete_buffer(YY_CURRENT_BUFFER);
-	yyterminate();
-}
@@ -1,726 +0,0 @@
-%{
-/*
-   +----------------------------------------------------------------------+
-   | Zend Engine                                                          |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
-   | that is bundled with this package in the file LICENSE, and is        | 
-   | available at through the world-wide-web at                           |
-   | http://www.zend.com/license/0_92.txt.                                |
-   | If you did not receive a copy of the Zend license and are unable to  |
-   | obtain it through the world-wide-web, please send a note to          |
-   | license@zend.com so we can mail you a copy immediately.              |
-   +----------------------------------------------------------------------+
-   | Authors: Andi Gutmans <andi@zend.com>                                |
-   |          Zeev Suraski <zeev@zend.com>                                |
-   +----------------------------------------------------------------------+
-*/
-
-/* 
- * LALR shift/reduce conflicts and how they are resolved:
- *
- * - 2 shift/reduce conflicts due to the dangeling elseif/else ambiguity.  Solved by shift.
- * - 1 shift/reduce conflict due to arrays within encapsulated strings. Solved by shift. 
- * - 1 shift/reduce conflict due to objects within encapsulated strings.  Solved by shift.
- * 
- */
-
-
-#include "zend_compile.h"
-#include "zend.h"
-#include "zend_list.h"
-#include "zend_globals.h"
-#include "zend_API.h"
-
-#define YYERROR_VERBOSE
-#define YYSTYPE znode
-#ifdef ZTS
-# define YYPARSE_PARAM compiler_globals
-# define YYLEX_PARAM compiler_globals
-#endif
-
-
-%}
-
-%pure_parser
-%expect 4
-
-%left T_INCLUDE T_INCLUDE_ONCE T_EVAL T_REQUIRE T_REQUIRE_ONCE
-%left ','
-%left T_LOGICAL_OR
-%left T_LOGICAL_XOR
-%left T_LOGICAL_AND
-%right T_PRINT
-%left '=' T_PLUS_EQUAL T_MINUS_EQUAL T_MUL_EQUAL T_DIV_EQUAL T_CONCAT_EQUAL T_MOD_EQUAL T_AND_EQUAL T_OR_EQUAL T_XOR_EQUAL T_SL_EQUAL T_SR_EQUAL
-%left '?' ':'
-%left T_BOOLEAN_OR
-%left T_BOOLEAN_AND
-%left '|'
-%left '^'
-%left '&'
-%nonassoc T_IS_EQUAL T_IS_NOT_EQUAL T_IS_IDENTICAL T_IS_NOT_IDENTICAL
-%nonassoc '<' T_IS_SMALLER_OR_EQUAL '>' T_IS_GREATER_OR_EQUAL
-%left T_SL T_SR
-%left '+' '-' '.'
-%left '*' '/' '%'
-%right '!' '~' T_INC T_DEC T_INT_CAST T_DOUBLE_CAST T_STRING_CAST T_ARRAY_CAST T_OBJECT_CAST T_BOOL_CAST T_UNSET_CAST '@'
-%right '['
-%nonassoc T_NEW
-%token T_EXIT
-%token T_IF
-%left T_ELSEIF
-%left T_ELSE
-%left T_ENDIF
-%token T_LNUMBER
-%token T_DNUMBER
-%token T_STRING
-%token T_STRING_VARNAME
-%token T_VARIABLE
-%token T_NUM_STRING
-%token T_INLINE_HTML
-%token T_CHARACTER
-%token T_BAD_CHARACTER
-%token T_ENCAPSED_AND_WHITESPACE
-%token T_CONSTANT_ENCAPSED_STRING
-%token T_ECHO
-%token T_DO
-%token T_WHILE
-%token T_ENDWHILE
-%token T_FOR
-%token T_ENDFOR
-%token T_FOREACH
-%token T_ENDFOREACH
-%token T_DECLARE
-%token T_ENDDECLARE
-%token T_AS
-%token T_SWITCH
-%token T_ENDSWITCH
-%token T_CASE
-%token T_DEFAULT
-%token T_BREAK
-%token T_CONTINUE
-%token T_OLD_FUNCTION
-%token T_FUNCTION
-%token T_CONST
-%token T_RETURN
-%token T_USE
-%token T_GLOBAL
-%token T_STATIC
-%token T_VAR
-%token T_UNSET
-%token T_ISSET
-%token T_EMPTY
-%token T_CLASS
-%token T_EXTENDS
-%token T_OBJECT_OPERATOR
-%token T_DOUBLE_ARROW
-%token T_LIST
-%token T_ARRAY
-%token T_LINE
-%token T_FILE
-%token T_COMMENT
-%token T_ML_COMMENT
-%token T_OPEN_TAG
-%token T_OPEN_TAG_WITH_ECHO
-%token T_CLOSE_TAG
-%token T_WHITESPACE
-%token T_START_HEREDOC
-%token T_END_HEREDOC
-%token T_DOLLAR_OPEN_CURLY_BRACES
-%token T_CURLY_OPEN
-%token T_PAAMAYIM_NEKUDOTAYIM
-
-%% /* Rules */
-
-start:
-	top_statement_list
-;
-
-top_statement_list:	
-		top_statement_list  { zend_do_extended_info(CLS_C); } top_statement { HANDLE_INTERACTIVE(); }
-	|	/* empty */
-;
-
-
-top_statement:
-		statement
-	|	declaration_statement	{ zend_do_early_binding(CLS_C); }
-;
-
-
-inner_statement_list:
-		inner_statement_list  { zend_do_extended_info(CLS_C); } inner_statement { HANDLE_INTERACTIVE(); }
-	|	/* empty */
-;
-
-
-inner_statement:
-		statement
-	|	declaration_statement
-;
-
-
-statement:
-		unticked_statement { zend_do_ticks(CLS_C); }
-;
-
-
-unticked_statement:
-		'{' inner_statement_list '}'
-	|	T_IF '(' expr ')' { zend_do_if_cond(&$3, &$4 CLS_CC); } statement { zend_do_if_after_statement(&$4, 1 CLS_CC); } elseif_list else_single { zend_do_if_end(CLS_C); }
-	|	T_IF '(' expr ')' ':' { zend_do_if_cond(&$3, &$4 CLS_CC); } inner_statement_list { zend_do_if_after_statement(&$4, 1 CLS_CC); } new_elseif_list new_else_single T_ENDIF ';' { zend_do_if_end(CLS_C); }
-	|	T_WHILE '(' { $1.u.opline_num = get_next_op_number(CG(active_op_array));  } expr  ')' { zend_do_while_cond(&$4, &$5 CLS_CC); } while_statement { zend_do_while_end(&$1, &$5 CLS_CC); }
-	|	T_DO { $1.u.opline_num = get_next_op_number(CG(active_op_array));  zend_do_do_while_begin(CLS_C); } statement T_WHILE '(' { $5.u.opline_num = get_next_op_number(CG(active_op_array)); } expr ')' ';' { zend_do_do_while_end(&$1, &$5, &$7 CLS_CC); }
-	|	T_FOR 
-			'('
-				for_expr
-			';' { zend_do_free(&$3 CLS_CC); $4.u.opline_num = get_next_op_number(CG(active_op_array)); }
-				for_expr
-			';' { zend_do_extended_info(CLS_C); zend_do_for_cond(&$6, &$7 CLS_CC); }
-				for_expr
-			')' { zend_do_free(&$9 CLS_CC); zend_do_for_before_statement(&$4, &$7 CLS_CC); }
-			for_statement { zend_do_for_end(&$7 CLS_CC); }
-	|	T_SWITCH '(' expr ')'	{ zend_do_switch_cond(&$3 CLS_CC); } switch_case_list { zend_do_switch_end(&$6 CLS_CC); }
-	|	T_BREAK ';'				{ zend_do_brk_cont(ZEND_BRK, NULL CLS_CC); }
-	|	T_BREAK expr ';'		{ zend_do_brk_cont(ZEND_BRK, &$2 CLS_CC); }
-	|	T_CONTINUE ';'			{ zend_do_brk_cont(ZEND_CONT, NULL CLS_CC); }
-	|	T_CONTINUE expr ';'		{ zend_do_brk_cont(ZEND_CONT, &$2 CLS_CC); }
-	|	T_RETURN ';'						{ zend_do_return(NULL, 0 CLS_CC); }
-	|	T_RETURN expr_without_variable ';'	{ zend_do_return(&$2, 0 CLS_CC); }
-	|	T_RETURN cvar ';'					{ zend_do_return(&$2, 1 CLS_CC); }
-	|	T_GLOBAL global_var_list ';'
-	|	T_STATIC static_var_list ';'
-	|	T_ECHO echo_expr_list ';'
-	|	T_INLINE_HTML			{ zend_do_echo(&$1 CLS_CC); }
-	|	expr ';'				{ zend_do_free(&$1 CLS_CC); }
-	|	T_USE use_filename ';'		{ zend_error(E_COMPILE_ERROR,"use: Not yet supported. Please use include_once() or require_once()");  zval_dtor(&$2.u.constant); }
-	|	T_UNSET '(' unset_variables ')' ';'
-	|	T_FOREACH '(' w_cvar T_AS { zend_do_foreach_begin(&$1, &$3, &$2, &$4, 1 CLS_CC); } w_cvar foreach_optional_arg ')' { zend_do_foreach_cont(&$6, &$7, &$4 CLS_CC); } foreach_statement { zend_do_foreach_end(&$1, &$2 CLS_CC); }
-	|	T_FOREACH '(' expr_without_variable T_AS { zend_do_foreach_begin(&$1, &$3, &$2, &$4, 0 CLS_CC); } w_cvar foreach_optional_arg ')' { zend_do_foreach_cont(&$6, &$7, &$4 CLS_CC); } foreach_statement { zend_do_foreach_end(&$1, &$2 CLS_CC); }
-	|	T_DECLARE { zend_do_declare_begin(CLS_C); } '(' declare_list ')' declare_statement { zend_do_declare_end(CLS_C); }
-	|	';'		/* empty statement */
-;
-
-unset_variables:
-		unset_variable
-	|	unset_variables ',' unset_variable
-;
-
-unset_variable:
-		cvar	{ zend_do_end_variable_parse(BP_VAR_UNSET, 0 CLS_CC); zend_do_unset(&$1 CLS_CC); }
-;
-
-use_filename:
-		T_CONSTANT_ENCAPSED_STRING			{ $$ = $1; }
-	|	'(' T_CONSTANT_ENCAPSED_STRING ')'	{ $$ = $2; }
-;
-
-
-declaration_statement:
-		unticked_declaration_statement	{ zend_do_ticks(CLS_C); }
-;
-
-
-unticked_declaration_statement:
-		T_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING { zend_do_begin_function_declaration(&$1, &$4, 0, $3.op_type CLS_CC); }
-			'(' parameter_list ')' '{' inner_statement_list '}' { zend_do_end_function_declaration(&$1 CLS_CC); }
-	|	T_OLD_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING  { zend_do_begin_function_declaration(&$1, &$4, 0, $3.op_type CLS_CC); }
-			parameter_list '(' inner_statement_list ')' ';' { zend_do_end_function_declaration(&$1 CLS_CC); }
-	|	T_CLASS T_STRING { zend_do_begin_class_declaration(&$2, NULL CLS_CC); } '{' class_statement_list '}' { zend_do_end_class_declaration(CLS_C); }
-	|	T_CLASS T_STRING T_EXTENDS T_STRING { zend_do_begin_class_declaration(&$2, &$4 CLS_CC); } '{' class_statement_list '}' { zend_do_end_class_declaration(CLS_C); }
-;
-
-
-foreach_optional_arg:
-		/* empty */				{ $$.op_type = IS_UNUSED; }
-	|	T_DOUBLE_ARROW w_cvar	{ $$ = $2; }
-;
-
-
-for_statement:
-		statement
-	|	':' inner_statement_list T_ENDFOR ';'
-;
-
-
-foreach_statement:
-		statement
-	|	':' inner_statement_list T_ENDFOREACH ';'
-;
-
-
-declare_statement:
-		statement
-	|	':' inner_statement_list T_ENDDECLARE ';'
-;
-
-
-declare_list:
-		T_STRING '=' static_scalar					{ zend_do_declare_stmt(&$1, &$3 CLS_CC); }
-	|	declare_list ',' T_STRING '=' static_scalar	{ zend_do_declare_stmt(&$3, &$5 CLS_CC); }
-;
-
-
-switch_case_list:
-		'{' case_list '}'					{ $$ = $2; }
-	|	'{' ';' case_list '}'				{ $$ = $3; }
-	|	':' case_list T_ENDSWITCH ';'		{ $$ = $2; }
-	|	':' ';' case_list T_ENDSWITCH ';'	{ $$ = $3; }
-;
-
-
-case_list:
-		/* empty */	{ $$.op_type = IS_UNUSED; }
-	|	case_list T_CASE expr case_separator { zend_do_extended_info(CLS_C);  zend_do_case_before_statement(&$1, &$2, &$3 CLS_CC); } inner_statement_list { zend_do_case_after_statement(&$$, &$2 CLS_CC); $$.op_type = IS_CONST }
-	|	case_list T_DEFAULT case_separator { zend_do_extended_info(CLS_C);  zend_do_default_before_statement(&$1, &$2 CLS_CC); } inner_statement_list { zend_do_case_after_statement(&$$, &$2 CLS_CC); $$.op_type = IS_CONST; }
-;
-
-
-case_separator:
-		':'
-	|	';'
-;
-
-
-while_statement:
-		statement
-	|	':' inner_statement_list T_ENDWHILE ';'
-;
-
-
-
-elseif_list:
-		/* empty */
-	|	elseif_list T_ELSEIF '(' expr ')' { zend_do_if_cond(&$4, &$5 CLS_CC); } statement { zend_do_if_after_statement(&$5, 0 CLS_CC); }
-;
-
-
-new_elseif_list:
-		/* empty */
-	|	new_elseif_list T_ELSEIF '(' expr ')' ':' { zend_do_if_cond(&$4, &$5 CLS_CC); } inner_statement_list { zend_do_if_after_statement(&$5, 0 CLS_CC); }
-;
-
-
-else_single:
-		/* empty */
-	|	T_ELSE statement
-;
-
-
-new_else_single:
-		/* empty */
-	|	T_ELSE ':' inner_statement_list
-;
-
-
-parameter_list: 
-		non_empty_parameter_list
-	|	/* empty */
-;
-
-
-non_empty_parameter_list:
-		T_VARIABLE				{ znode tmp;  fetch_simple_variable(&tmp, &$1, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; INIT_PZVAL(&$$.u.constant); zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE CLS_CC); }
-	|	'&' T_VARIABLE			{ znode tmp;  fetch_simple_variable(&tmp, &$2, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; INIT_PZVAL(&$$.u.constant); zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_FORCE CLS_CC); }
-	|	T_CONST T_VARIABLE 		{ znode tmp;  fetch_simple_variable(&tmp, &$2, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; INIT_PZVAL(&$$.u.constant); zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE CLS_CC); }
-	|	T_VARIABLE '=' static_scalar				{ znode tmp;  fetch_simple_variable(&tmp, &$1, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; INIT_PZVAL(&$$.u.constant); zend_do_receive_arg(ZEND_RECV_INIT, &tmp, &$$, &$3, BYREF_NONE CLS_CC); }
-	|	non_empty_parameter_list ',' T_VARIABLE 	{ znode tmp;  fetch_simple_variable(&tmp, &$3, 0 CLS_CC); $$=$1; $$.u.constant.value.lval++; zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE CLS_CC); }
-	|	non_empty_parameter_list ',' '&' T_VARIABLE	{ znode tmp;  fetch_simple_variable(&tmp, &$4, 0 CLS_CC); $$=$1; $$.u.constant.value.lval++; zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_FORCE CLS_CC); }
-	|	non_empty_parameter_list ',' T_CONST T_VARIABLE				{ znode tmp;  fetch_simple_variable(&tmp, &$4, 0 CLS_CC); $$=$1; $$.u.constant.value.lval++; zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE CLS_CC); }
-	|	non_empty_parameter_list ',' T_VARIABLE '=' static_scalar 	{ znode tmp;  fetch_simple_variable(&tmp, &$3, 0 CLS_CC); $$=$1; $$.u.constant.value.lval++; zend_do_receive_arg(ZEND_RECV_INIT, &tmp, &$$, &$5, BYREF_NONE CLS_CC); }
-;
-
-
-function_call_parameter_list:
-		non_empty_function_call_parameter_list	{ $$ = $1; }
-	|	/* empty */				{ $$.u.constant.value.lval = 0; }
-;
-
-
-non_empty_function_call_parameter_list:
-		expr_without_variable	{ $$.u.constant.value.lval = 1;  zend_do_pass_param(&$1, ZEND_SEND_VAL, $$.u.constant.value.lval CLS_CC); }
-	|	cvar					{ $$.u.constant.value.lval = 1;  zend_do_pass_param(&$1, ZEND_SEND_VAR, $$.u.constant.value.lval CLS_CC); }
-	|	'&' w_cvar 				{ $$.u.constant.value.lval = 1;  zend_do_pass_param(&$2, ZEND_SEND_REF, $$.u.constant.value.lval CLS_CC); }
-	|	non_empty_function_call_parameter_list ',' expr_without_variable	{ $$.u.constant.value.lval=$1.u.constant.value.lval+1;  zend_do_pass_param(&$3, ZEND_SEND_VAL, $$.u.constant.value.lval CLS_CC); }
-	|	non_empty_function_call_parameter_list ',' cvar						{ $$.u.constant.value.lval=$1.u.constant.value.lval+1;  zend_do_pass_param(&$3, ZEND_SEND_VAR, $$.u.constant.value.lval CLS_CC); }
-	|	non_empty_function_call_parameter_list ',' '&' w_cvar				{ $$.u.constant.value.lval=$1.u.constant.value.lval+1;  zend_do_pass_param(&$4, ZEND_SEND_REF, $$.u.constant.value.lval CLS_CC); }
-;
-
-global_var_list:
-		global_var_list ',' global_var	{ zend_do_fetch_global_or_static_variable(&$3, NULL, ZEND_FETCH_GLOBAL CLS_CC); }
-	|	global_var						{ zend_do_fetch_global_or_static_variable(&$1, NULL, ZEND_FETCH_GLOBAL CLS_CC); }
-;
-
-
-global_var:
-		T_VARIABLE			{ $$ = $1; }
-	|	'$' r_cvar			{ $$ = $2; }
-	|	'$' '{' expr '}'	{ $$ = $3; }
-;
-
-
-static_var_list:
-		static_var_list ',' T_VARIABLE { zend_do_fetch_global_or_static_variable(&$3, NULL, ZEND_FETCH_STATIC CLS_CC); }
-	|	static_var_list ',' T_VARIABLE '=' static_scalar { zend_do_fetch_global_or_static_variable(&$3, &$5, ZEND_FETCH_STATIC CLS_CC); }
-	|	T_VARIABLE  { zend_do_fetch_global_or_static_variable(&$1, NULL, ZEND_FETCH_STATIC CLS_CC); }
-	|	T_VARIABLE '=' static_scalar { zend_do_fetch_global_or_static_variable(&$1, &$3, ZEND_FETCH_STATIC CLS_CC); }
-
-;
-
-
-class_statement_list:
-		class_statement_list class_statement
-	|	/* empty */
-;
-
-
-class_statement:
-		T_VAR class_variable_decleration ';'
-	|	T_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING { zend_do_begin_function_declaration(&$1, &$4, 1, $3.op_type CLS_CC); } '(' 
-			parameter_list ')' '{' inner_statement_list '}' { zend_do_end_function_declaration(&$1 CLS_CC); }
-	|	T_OLD_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING { zend_do_begin_function_declaration(&$1, &$4, 1, $3.op_type CLS_CC); }
-			parameter_list '(' inner_statement_list ')' ';' { zend_do_end_function_declaration(&$1 CLS_CC); }
-
-;
-
-is_reference:
-		/* empty */	{ $$.op_type = ZEND_RETURN_VAL; }
-	|	'&'			{ $$.op_type = ZEND_RETURN_REF; }
-
-class_variable_decleration:
-		class_variable_decleration ',' T_VARIABLE					{ zend_do_declare_property(&$3, NULL CLS_CC); }
-	|	class_variable_decleration ',' T_VARIABLE '=' static_scalar	{ zend_do_declare_property(&$3, &$5 CLS_CC); }
-	|	T_VARIABLE						{ zend_do_declare_property(&$1, NULL CLS_CC); }
-	|	T_VARIABLE '=' static_scalar	{ zend_do_declare_property(&$1, &$3 CLS_CC); }
-;
-
-
-echo_expr_list:	
-	|	echo_expr_list ',' expr { zend_do_echo(&$3 CLS_CC); }
-	|	expr					{ zend_do_echo(&$1 CLS_CC); }
-;
-
-
-for_expr:
-		/* empty */			{ $$.op_type = IS_CONST;  $$.u.constant.type = IS_BOOL;  $$.u.constant.value.lval = 1; }
-	|	non_empty_for_expr	{ $$ = $1; }
-;
-
-non_empty_for_expr:
-		non_empty_for_expr ','	{ zend_do_free(&$1 CLS_CC); } expr { $$ = $4; }
-	|	expr					{ $$ = $1; }
-;
-
-
-expr_without_variable:	
-		T_LIST '(' { zend_do_list_init(CLS_C); } assignment_list ')' '=' expr { zend_do_list_end(&$$, &$7 CLS_CC); }
-	|	cvar '=' expr		{ zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC); zend_do_assign(&$$, &$1, &$3 CLS_CC); }
-	|	cvar '=' '&' w_cvar	{ zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC); zend_do_assign_ref(&$$, &$1, &$4 CLS_CC); }
-	|	cvar '=' '&' function_call { zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC); zend_do_assign_ref(&$$, &$1, &$4 CLS_CC); }
-	|	cvar '=' '&' T_NEW class_name { zend_do_extended_fcall_begin(CLS_C); zend_do_begin_new_object(&$4, &$5 CLS_CC); } ctor_arguments { zend_do_end_new_object(&$3, &$5, &$4, &$7 CLS_CC); zend_do_extended_fcall_end(CLS_C); zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC); zend_do_assign_ref(&$$, &$1, &$3 CLS_CC); }
-	|	T_NEW class_name { zend_do_extended_fcall_begin(CLS_C); zend_do_begin_new_object(&$1, &$2 CLS_CC); } ctor_arguments { zend_do_end_new_object(&$$, &$2, &$1, &$4 CLS_CC); zend_do_extended_fcall_end(CLS_C);}
-	|	cvar T_PLUS_EQUAL expr 	{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_ADD, &$$, &$1, &$3 CLS_CC); }
-	|	cvar T_MINUS_EQUAL expr	{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SUB, &$$, &$1, &$3 CLS_CC); }
-	|	cvar T_MUL_EQUAL expr		{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_MUL, &$$, &$1, &$3 CLS_CC); }
-	|	cvar T_DIV_EQUAL expr		{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_DIV, &$$, &$1, &$3 CLS_CC); }
-	|	cvar T_CONCAT_EQUAL expr	{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_CONCAT, &$$, &$1, &$3 CLS_CC); }
-	|	cvar T_MOD_EQUAL expr		{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_MOD, &$$, &$1, &$3 CLS_CC); }
-	|	cvar T_AND_EQUAL expr		{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_AND, &$$, &$1, &$3 CLS_CC); }
-	|	cvar T_OR_EQUAL expr 		{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_OR, &$$, &$1, &$3 CLS_CC); }
-	|	cvar T_XOR_EQUAL expr 		{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_XOR, &$$, &$1, &$3 CLS_CC); }
-	|	cvar T_SL_EQUAL expr	{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SL, &$$, &$1, &$3 CLS_CC); } 
-	|	cvar T_SR_EQUAL expr	{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SR, &$$, &$1, &$3 CLS_CC); } 
-	|	rw_cvar T_INC { zend_do_post_incdec(&$$, &$1, ZEND_POST_INC CLS_CC); }
-	|	T_INC rw_cvar { zend_do_pre_incdec(&$$, &$2, ZEND_PRE_INC CLS_CC); }
-	|	rw_cvar T_DEC { zend_do_post_incdec(&$$, &$1, ZEND_POST_DEC CLS_CC); }
-	|	T_DEC rw_cvar { zend_do_pre_incdec(&$$, &$2, ZEND_PRE_DEC CLS_CC); }
-	|	expr T_BOOLEAN_OR { zend_do_boolean_or_begin(&$1, &$2 CLS_CC); } expr { zend_do_boolean_or_end(&$$, &$1, &$4, &$2 CLS_CC); }
-	|	expr T_BOOLEAN_AND { zend_do_boolean_and_begin(&$1, &$2 CLS_CC); } expr { zend_do_boolean_and_end(&$$, &$1, &$4, &$2 CLS_CC); }  
-	|	expr T_LOGICAL_OR { zend_do_boolean_or_begin(&$1, &$2 CLS_CC); } expr { zend_do_boolean_or_end(&$$, &$1, &$4, &$2 CLS_CC); }
-	|	expr T_LOGICAL_AND { zend_do_boolean_and_begin(&$1, &$2 CLS_CC); } expr { zend_do_boolean_and_end(&$$, &$1, &$4, &$2 CLS_CC); }
-	|	expr T_LOGICAL_XOR expr { zend_do_binary_op(ZEND_BOOL_XOR, &$$, &$1, &$3 CLS_CC); }
-	|	expr '|' expr	{ zend_do_binary_op(ZEND_BW_OR, &$$, &$1, &$3 CLS_CC); }
-	|	expr '&' expr	{ zend_do_binary_op(ZEND_BW_AND, &$$, &$1, &$3 CLS_CC); }
-	|	expr '^' expr	{ zend_do_binary_op(ZEND_BW_XOR, &$$, &$1, &$3 CLS_CC); }
-	|	expr '.' expr 	{ zend_do_binary_op(ZEND_CONCAT,&$$,&$1,&$3 CLS_CC); }
-	|	expr '+' expr 	{ zend_do_binary_op(ZEND_ADD,&$$,&$1,&$3 CLS_CC); }
-	|	expr '-' expr 	{ zend_do_binary_op(ZEND_SUB,&$$,&$1,&$3 CLS_CC); }
-	|	expr '*' expr	{ zend_do_binary_op(ZEND_MUL,&$$,&$1,&$3 CLS_CC); }
-	|	expr '/' expr	{ zend_do_binary_op(ZEND_DIV,&$$,&$1,&$3 CLS_CC); }
-	|	expr '%' expr 	{ zend_do_binary_op(ZEND_MOD,&$$,&$1,&$3 CLS_CC); }
-	| 	expr T_SL expr	{ zend_do_binary_op(ZEND_SL, &$$, &$1, &$3 CLS_CC); }
-	|	expr T_SR expr	{ zend_do_binary_op(ZEND_SR, &$$, &$1, &$3 CLS_CC); }
-	|	'+' expr { $1.u.constant.value.lval=0; $1.u.constant.type=IS_LONG; $1.op_type = IS_CONST; INIT_PZVAL(&$1.u.constant); zend_do_binary_op(ZEND_ADD, &$$, &$1, &$2 CLS_CC); }
-	|	'-' expr { $1.u.constant.value.lval=0; $1.u.constant.type=IS_LONG; $1.op_type = IS_CONST; INIT_PZVAL(&$1.u.constant); zend_do_binary_op(ZEND_SUB, &$$, &$1, &$2 CLS_CC); }
-	|	'!' expr { zend_do_unary_op(ZEND_BOOL_NOT, &$$, &$2 CLS_CC); }
-	|	'~' expr { zend_do_unary_op(ZEND_BW_NOT, &$$, &$2 CLS_CC); }
-	|	expr T_IS_IDENTICAL expr		{ zend_do_binary_op(ZEND_IS_IDENTICAL, &$$, &$1, &$3 CLS_CC); }
-	|	expr T_IS_NOT_IDENTICAL expr	{ zend_do_binary_op(ZEND_IS_NOT_IDENTICAL, &$$, &$1, &$3 CLS_CC); }
-	|	expr T_IS_EQUAL expr			{ zend_do_binary_op(ZEND_IS_EQUAL, &$$, &$1, &$3 CLS_CC); }
-	|	expr T_IS_NOT_EQUAL expr 		{ zend_do_binary_op(ZEND_IS_NOT_EQUAL, &$$, &$1, &$3 CLS_CC); }
-	|	expr '<' expr 					{ zend_do_binary_op(ZEND_IS_SMALLER, &$$, &$1, &$3 CLS_CC); }
-	|	expr T_IS_SMALLER_OR_EQUAL expr { zend_do_binary_op(ZEND_IS_SMALLER_OR_EQUAL, &$$, &$1, &$3 CLS_CC); }
-	|	expr '>' expr 					{ zend_do_binary_op(ZEND_IS_SMALLER, &$$, &$3, &$1 CLS_CC); }
-	|	expr T_IS_GREATER_OR_EQUAL expr { zend_do_binary_op(ZEND_IS_SMALLER_OR_EQUAL, &$$, &$3, &$1 CLS_CC); }
-	|	'(' expr ')' 	{ $$ = $2; }
-	|	expr '?' { zend_do_begin_qm_op(&$1, &$2 CLS_CC); }
-		expr ':' { zend_do_qm_true(&$4, &$2, &$5 CLS_CC); }
-		expr	 { zend_do_qm_false(&$$, &$7, &$2, &$5 CLS_CC); }
-	|	function_call { $$ = $1; }
-	|	internal_functions_in_yacc { $$ = $1; }
-	|	T_INT_CAST expr 	{ zend_do_cast(&$$, &$2, IS_LONG CLS_CC); }
-	|	T_DOUBLE_CAST expr 	{ zend_do_cast(&$$, &$2, IS_DOUBLE CLS_CC); }
-	|	T_STRING_CAST expr	{ zend_do_cast(&$$, &$2, IS_STRING CLS_CC); } 
-	|	T_ARRAY_CAST expr 	{ zend_do_cast(&$$, &$2, IS_ARRAY CLS_CC); }
-	|	T_OBJECT_CAST expr 	{ zend_do_cast(&$$, &$2, IS_OBJECT CLS_CC); }
-	|	T_BOOL_CAST expr	{ zend_do_cast(&$$, &$2, IS_BOOL CLS_CC); }
-	|	T_UNSET_CAST expr	{ zend_do_cast(&$$, &$2, IS_NULL CLS_CC); }
-	|	T_EXIT exit_expr	{ zend_do_exit(&$$, &$2 CLS_CC); }
-	|	'@' { zend_do_begin_silence(&$1 CLS_CC); } expr { zend_do_end_silence(&$1 CLS_CC); $$ = $3; }
-	|	scalar				{ $$ = $1; }
-	|	T_ARRAY '(' array_pair_list ')' { $$ = $3; }
-	|	'`' encaps_list '`'		{ zend_do_shell_exec(&$$, &$2 CLS_CC); }
-	|	T_PRINT expr  { zend_do_print(&$$, &$2 CLS_CC); }
-;
-
-function_call:
-		T_STRING	'(' { $2.u.opline_num = zend_do_begin_function_call(&$1 CLS_CC); }
-				function_call_parameter_list
-				')' { zend_do_end_function_call(&$1, &$$, &$4, 0, $2.u.opline_num CLS_CC); zend_do_extended_fcall_end(CLS_C); }
-	|	cvar '(' { zend_do_begin_dynamic_function_call(&$1 CLS_CC); } 
-				function_call_parameter_list 
-				')' { zend_do_end_function_call(&$1, &$$, &$4, 0, 1 CLS_CC); zend_do_extended_fcall_end(CLS_C);}
-	|	T_STRING T_PAAMAYIM_NEKUDOTAYIM T_STRING '(' { zend_do_extended_fcall_begin(CLS_C); zend_do_begin_class_member_function_call(&$1, &$3 CLS_CC); } 
-											function_call_parameter_list 
-											')' { zend_do_end_function_call(&$3, &$$, &$6, 1, 1 CLS_CC); zend_do_extended_fcall_end(CLS_C);}
-;
-
-
-exit_expr:
-		/* empty */	{ memset(&$$, 0, sizeof(znode)); $$.op_type = IS_UNUSED; }	
-	|	'(' ')'		{ memset(&$$, 0, sizeof(znode)); $$.op_type = IS_UNUSED; }	
-	|	'(' expr ')'	{ $$ = $2; }
-;
-
-
-ctor_arguments:
-		/* empty */	{ $$.u.constant.value.lval=0; }
-	|	'(' function_call_parameter_list ')'	{ $$ = $2; }
-;
-
-
-class_name:
-		T_STRING	{ $$ = $1; }
-	|	r_cvar		{ $$ = $1; }
-;
-
-
-
-common_scalar:
-		T_LNUMBER 					{ $$ = $1; }
-	|	T_DNUMBER 					{ $$ = $1; }
-	|	T_CONSTANT_ENCAPSED_STRING	{ $$ = $1; }
-	|	T_LINE 						{ $$ = $1; }
-	|	T_FILE 						{ $$ = $1; }
-;
-
-
-static_scalar: /* compile-time evaluated scalars */
-		common_scalar		{ $$ = $1; }
-	|	T_STRING 		{ zend_do_fetch_constant(&$$, &$1, ZEND_CT CLS_CC); }
-	|	'+' static_scalar	{ $$ = $1; }
-	|	'-' static_scalar	{ zval minus_one;  minus_one.type = IS_LONG; minus_one.value.lval = -1;  mul_function(&$2.u.constant, &$2.u.constant, &minus_one);  $$ = $2; }
-	|	T_ARRAY '(' static_array_pair_list ')' { $$ = $3; $$.u.constant.type = IS_CONSTANT_ARRAY; }
-;
-
-
-scalar:
-		T_STRING 				{ zend_do_fetch_constant(&$$, &$1, ZEND_RT CLS_CC); }
-	|	T_STRING_VARNAME		{ $$ = $1; }
-	|	common_scalar			{ $$ = $1; }
-	|	'"' encaps_list '"' 	{ $$ = $2; }
-	|	'\'' encaps_list '\''	{ $$ = $2; }
-	|	T_START_HEREDOC encaps_list T_END_HEREDOC { $$ = $2; zend_do_end_heredoc(CLS_C); }
-;
-
-
-static_array_pair_list:
-		/* empty */ { $$.op_type = IS_CONST; INIT_PZVAL(&$$.u.constant); array_init(&$$.u.constant); }
-	|	non_empty_static_array_pair_list possible_comma	{ $$ = $1; }
-;
-
-possible_comma:
-		/* empty */
-	|	','
-;
-
-non_empty_static_array_pair_list:
-		non_empty_static_array_pair_list ',' static_scalar T_DOUBLE_ARROW static_scalar	{ zend_do_add_static_array_element(&$$, &$3, &$5); }
-	|	non_empty_static_array_pair_list ',' static_scalar { zend_do_add_static_array_element(&$$, NULL, &$3); }
-	|	static_scalar T_DOUBLE_ARROW static_scalar { $$.op_type = IS_CONST; INIT_PZVAL(&$$.u.constant); array_init(&$$.u.constant); zend_do_add_static_array_element(&$$, &$1, &$3); }
-	|	static_scalar { $$.op_type = IS_CONST; INIT_PZVAL(&$$.u.constant); array_init(&$$.u.constant); zend_do_add_static_array_element(&$$, NULL, &$1); }
-;
-
-expr:
-		r_cvar					{ $$ = $1; }
-	|	expr_without_variable	{ $$ = $1; }
-;
-
-/*
-w_expr:
-		w_cvar					{ $$ = $1; }
-	|	expr_without_variable	{ $$ = $1; }
-;
-*/
-
-
-r_cvar:
-	cvar { zend_do_end_variable_parse(BP_VAR_R, 0 CLS_CC); $$ = $1; }
-;
-
-
-w_cvar:
-	cvar { zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC); $$ = $1; }
-;
-
-
-rw_cvar:
-	cvar { zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); $$ = $1; }
-;
-
-
-cvar:
-		cvar_without_objects { $$ = $1; }
-	|	cvar_without_objects T_OBJECT_OPERATOR { zend_do_push_object(&$1 CLS_CC); } ref_list { $$ = $4; }
-;
-
-
-cvar_without_objects:
-		reference_variable { $$ = $1; }
-	|	simple_indirect_reference reference_variable { zend_do_indirect_references(&$$, &$1, &$2 CLS_CC); }
-;
-
-
-reference_variable:
-		reference_variable '[' dim_offset ']'	{ fetch_array_dim(&$$, &$1, &$3 CLS_CC); }
-	|	reference_variable '{' expr '}'		{ fetch_string_offset(&$$, &$1, &$3 CLS_CC); }
-	|	compound_variable			{ zend_do_fetch_globals(&$1 CLS_CC); zend_do_begin_variable_parse(CLS_C); fetch_simple_variable(&$$, &$1, 1 CLS_CC); }
-;
-	
-
-compound_variable:
-		T_VARIABLE			{ $$ = $1; }
-	|	'$' '{' expr '}'	{ $$ = $3; }
-;
-
-dim_offset:
-		/* empty */		{ $$.op_type = IS_UNUSED; }
-	|	expr			{ $$ = $1; }
-;
-
-ref_list:
-		object_property  { $$ = $1; }
-	|	ref_list T_OBJECT_OPERATOR { zend_do_push_object(&$1 CLS_CC); } object_property { $$ = $4; }
-;
-
-object_property:
-		object_dim_list { $$ = $1; }
-	|	cvar_without_objects { zend_do_end_variable_parse(BP_VAR_R, 0 CLS_CC); } { znode tmp_znode;  zend_do_pop_object(&tmp_znode CLS_CC);  zend_do_fetch_property(&$$, &tmp_znode, &$1 CLS_CC);}
-;
-
-object_dim_list:
-		object_dim_list '[' dim_offset ']'	{ fetch_array_dim(&$$, &$1, &$3 CLS_CC); }
-	|	object_dim_list '{' expr '}'		{ fetch_string_offset(&$$, &$1, &$3 CLS_CC); }
-	|	variable_name { znode tmp_znode;  zend_do_pop_object(&tmp_znode CLS_CC);  zend_do_fetch_property(&$$, &tmp_znode, &$1 CLS_CC);}
-;
-
-variable_name:
-		T_STRING		{ $$ = $1; }
-	|	'{' expr '}'	{ $$ = $2; }
-;
-
-
-simple_indirect_reference:
-		'$' { $$.u.constant.value.lval = 1; }
-	|	simple_indirect_reference '$' { $$.u.constant.value.lval++; }
-;
-
-assignment_list:
-		assignment_list ',' assignment_list_element
-	|	assignment_list_element
-;
-
-
-assignment_list_element:
-		cvar								{ zend_do_add_list_element(&$1 CLS_CC); }
-	|	T_LIST '(' { zend_do_new_list_begin(CLS_C); } assignment_list ')'	{ zend_do_new_list_end(CLS_C); }
-	|	/* empty */							{ zend_do_add_list_element(NULL CLS_CC); }
-;
-
-
-array_pair_list:
-		/* empty */ { zend_do_init_array(&$$, NULL, NULL, 0 CLS_CC); }
-	|	non_empty_array_pair_list possible_comma	{ $$ = $1; }
-;
-
-non_empty_array_pair_list:
-		non_empty_array_pair_list ',' expr T_DOUBLE_ARROW expr	{ zend_do_add_array_element(&$$, &$5, &$3, 0 CLS_CC); }
-	|	non_empty_array_pair_list ',' expr			{ zend_do_add_array_element(&$$, &$3, NULL, 0 CLS_CC); }
-	|	expr T_DOUBLE_ARROW expr	{ zend_do_init_array(&$$, &$3, &$1, 0 CLS_CC); }
-	|	expr 				{ zend_do_init_array(&$$, &$1, NULL, 0 CLS_CC); }
-	|	non_empty_array_pair_list ',' expr T_DOUBLE_ARROW '&' w_cvar { zend_do_add_array_element(&$$, &$6, &$3, 1 CLS_CC); }
-	|	non_empty_array_pair_list ',' '&' w_cvar { zend_do_add_array_element(&$$, &$4, NULL, 1 CLS_CC); }
-	|	expr T_DOUBLE_ARROW '&' w_cvar	{ zend_do_init_array(&$$, &$4, &$1, 1 CLS_CC); }
-	|	'&' w_cvar 			{ zend_do_init_array(&$$, &$2, NULL, 1 CLS_CC); }
-;
-
-encaps_list:
-		encaps_list encaps_var { zend_do_end_variable_parse(BP_VAR_R, 0 CLS_CC);  zend_do_add_variable(&$$, &$1, &$2 CLS_CC); }
-	|	encaps_list T_STRING			{ zend_do_add_string(&$$, &$1, &$2 CLS_CC); }
-	|	encaps_list T_NUM_STRING		{ zend_do_add_string(&$$, &$1, &$2 CLS_CC); }
-	|	encaps_list T_ENCAPSED_AND_WHITESPACE	{ zend_do_add_string(&$$, &$1, &$2 CLS_CC); }
-	|	encaps_list T_CHARACTER 		{ zend_do_add_char(&$$, &$1, &$2 CLS_CC); }
-	|	encaps_list T_BAD_CHARACTER		{ zend_do_add_string(&$$, &$1, &$2 CLS_CC); }
-	|	encaps_list '['		{ $2.u.constant.value.lval = (long) '['; zend_do_add_char(&$$, &$1, &$2 CLS_CC); }
-	|	encaps_list ']'		{ $2.u.constant.value.lval = (long) ']'; zend_do_add_char(&$$, &$1, &$2 CLS_CC); }
-	|	encaps_list '{'		{ $2.u.constant.value.lval = (long) '{'; zend_do_add_char(&$$, &$1, &$2 CLS_CC); }
-	|	encaps_list '}'		{ $2.u.constant.value.lval = (long) '}'; zend_do_add_char(&$$, &$1, &$2 CLS_CC); }
-	|	encaps_list T_OBJECT_OPERATOR  { znode tmp;  $2.u.constant.value.lval = (long) '-';  zend_do_add_char(&tmp, &$1, &$2 CLS_CC);  $2.u.constant.value.lval = (long) '>'; zend_do_add_char(&$$, &tmp, &$2 CLS_CC); }
-	|	/* empty */			{ zend_do_init_string(&$$ CLS_CC); }
-
-;
-
-
-
-encaps_var:
-		T_VARIABLE { zend_do_fetch_globals(&$1 CLS_CC); zend_do_begin_variable_parse(CLS_C); fetch_simple_variable(&$$, &$1, 1 CLS_CC); }
-	|	T_VARIABLE '[' { zend_do_begin_variable_parse(CLS_C); } encaps_var_offset ']'	{ zend_do_fetch_globals(&$1 CLS_CC);  fetch_array_begin(&$$, &$1, &$4 CLS_CC); }
-	|	T_VARIABLE T_OBJECT_OPERATOR T_STRING { zend_do_begin_variable_parse(CLS_C); fetch_simple_variable(&$2, &$1, 1 CLS_CC); zend_do_fetch_property(&$$, &$2, &$3 CLS_CC); }
-	|	T_DOLLAR_OPEN_CURLY_BRACES expr '}' { zend_do_begin_variable_parse(CLS_C);  fetch_simple_variable(&$$, &$2, 1 CLS_CC); }
-	|	T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '[' expr ']' '}' { zend_do_begin_variable_parse(CLS_C);  fetch_array_begin(&$$, &$2, &$4 CLS_CC); }
-	|	T_CURLY_OPEN cvar '}' { $$ = $2; }
-;
-
-
-encaps_var_offset:
-		T_STRING		{ $$ = $1; }
-	|	T_NUM_STRING	{ $$ = $1; }
-	|	T_VARIABLE		{ fetch_simple_variable(&$$, &$1, 1 CLS_CC); }
-;
-
-
-internal_functions_in_yacc:
-		T_ISSET '(' cvar ')'	{ zend_do_isset_or_isempty(ZEND_ISSET, &$$, &$3 CLS_CC); }
-	|	T_EMPTY '(' cvar ')'	{ zend_do_isset_or_isempty(ZEND_ISEMPTY, &$$, &$3 CLS_CC); }
-	|	T_INCLUDE expr 			{ zend_do_include_or_eval(ZEND_INCLUDE, &$$, &$2 CLS_CC); }
-	|	T_INCLUDE_ONCE expr 	{ zend_do_include_or_eval(ZEND_INCLUDE_ONCE, &$$, &$2 CLS_CC); }
-	|	T_EVAL '(' expr ')' 	{ zend_do_include_or_eval(ZEND_EVAL, &$$, &$3 CLS_CC); }
-	|	T_REQUIRE expr			{ zend_do_include_or_eval(ZEND_REQUIRE, &$$, &$2 CLS_CC); }
-	|	T_REQUIRE_ONCE expr		{ zend_do_include_or_eval(ZEND_REQUIRE_ONCE, &$$, &$2 CLS_CC); }
-;
-
-
-%%
-
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -27,14 +27,10 @@

 ZEND_API int le_index_ptr;

-/* true global */
-static HashTable list_destructors;
-
-
-static inline int zend_list_do_insert(HashTable *list, void *ptr, int type, zend_bool valid)
+static inline int zend_list_do_insert(HashTable *list,void *ptr, int type)
 {
 	int index;
-	zend_rsrc_list_entry le;
+	list_entry le;

 	index = zend_hash_next_free_element(list);

@@ -43,14 +39,13 @@ static inline int zend_list_do_insert(HashTable *list, void *ptr, int type, zend
 	le.ptr=ptr;
 	le.type=type;
 	le.refcount=1;
-	le.valid = valid;
-	zend_hash_index_update(list, index, (void *) &le, sizeof(zend_rsrc_list_entry), NULL);
+	zend_hash_index_update(list, index, (void *) &le, sizeof(list_entry), NULL);
 	return index;
 }

 static inline int zend_list_do_delete(HashTable *list,int id)
 {
-	zend_rsrc_list_entry *le;
+	list_entry *le;
 	ELS_FETCH();
 	
 	if (zend_hash_index_find(&EG(regular_list), id, (void **) &le)==SUCCESS) {
@@ -68,7 +63,7 @@ static inline int zend_list_do_delete(HashTable *list,int id)

 static inline void *zend_list_do_find(HashTable *list,int id, int *type)
 {
-	zend_rsrc_list_entry *le;
+	list_entry *le;

 	if (zend_hash_index_find(list, id, (void **) &le)==SUCCESS) {
 		*type = le->type;
@@ -84,7 +79,7 @@ ZEND_API int zend_list_insert(void *ptr, int type)
 {
 	ELS_FETCH();

-	return zend_list_do_insert(&EG(regular_list), ptr, type, 1);
+	return zend_list_do_insert(&EG(regular_list), ptr, type);
 }


@@ -92,13 +87,13 @@ ZEND_API int zend_plist_insert(void *ptr, int type)
 {
 	ELS_FETCH();

-	return zend_list_do_insert(&EG(persistent_list), ptr, type, 1);
+	return zend_list_do_insert(&EG(persistent_list), ptr, type);
 }


 ZEND_API int zend_list_addref(int id)
 {
-	zend_rsrc_list_entry *le;
+	list_entry *le;
 	ELS_FETCH();
 	
 	if (zend_hash_index_find(&EG(regular_list), id, (void **) &le)==SUCCESS) {
@@ -127,20 +122,6 @@ ZEND_API int zend_plist_delete(int id)
 }


-ZEND_API int zend_list_convert_to_number(int id)
-{
-	zend_rsrc_list_entry *le;
-	ELS_FETCH();
-	
-	if (zend_hash_index_find(&EG(regular_list), id, (void **) &le)==SUCCESS
-		&& le->valid) {
-		return id;
-	}
-	return 0;
-}
-
-
-
 ZEND_API void *zend_list_find(int id, int *type)
 {
 	ELS_FETCH();
@@ -158,7 +139,7 @@ ZEND_API void *zend_plist_find(int id, int *type)


 ZEND_API int zend_register_resource(zval *rsrc_result, void *rsrc_pointer, int rsrc_type)
-{
+{	
 	int rsrc_id;

 	rsrc_id = zend_list_insert(rsrc_pointer, rsrc_type);
@@ -172,22 +153,6 @@ ZEND_API int zend_register_resource(zval *rsrc_result, void *rsrc_pointer, int r
 }


-ZEND_API int zend_register_false_resource(zval *rsrc_result, void *rsrc_pointer, int rsrc_type)
-{
-	int rsrc_id;
-	ELS_FETCH();
-
-	rsrc_id = zend_list_do_insert(&EG(regular_list), rsrc_pointer, rsrc_type, 0);
-	
-	if (rsrc_result) {
-		rsrc_result->value.lval = rsrc_id;
-		rsrc_result->type = IS_RESOURCE;
-	}
-
-	return rsrc_id;
-}
-
-
 ZEND_API void *zend_fetch_resource(zval **passed_id, int default_id, char *resource_type_name, int *found_resource_type, int num_resource_types, ...)
 {
 	int id;
@@ -215,9 +180,8 @@ ZEND_API void *zend_fetch_resource(zval **passed_id, int default_id, char *resou

 	resource = zend_list_find(id, &actual_resource_type);
 	if (!resource) {
-		if (resource_type_name) {
+		if (resource_type_name)
 			zend_error(E_WARNING, "%d is not a valid %s resource", id, resource_type_name);
-		}
 		return NULL;
 	}

@@ -233,79 +197,74 @@ ZEND_API void *zend_fetch_resource(zval **passed_id, int default_id, char *resou
 	}
 	va_end(resource_types);

-	if (resource_type_name) {
+	if (resource_type_name)
 		zend_error(E_WARNING, "Supplied resource is not a valid %s resource", resource_type_name);
-	}

 	return NULL;
 }


-void list_entry_destructor(void *ptr)
+int list_entry_destructor(void *ptr)
 {
-	zend_rsrc_list_entry *le = (zend_rsrc_list_entry *) ptr;
-	zend_rsrc_list_dtors_entry *ld;
+	list_entry *le = (list_entry *) ptr;
+	list_destructors_entry *ld;
 	
-	if (zend_hash_index_find(&list_destructors, le->type,(void **) &ld)==SUCCESS) {
-		switch (ld->type) {
-			case ZEND_RESOURCE_LIST_TYPE_STD:
-				if (ld->list_dtor) {
-					(ld->list_dtor)(le->ptr);
-				}
-				break;
-			case ZEND_RESOURCE_LIST_TYPE_EX:
-				if (ld->list_dtor_ex) {
-					ld->list_dtor_ex(le);
-				}
-				break;
-			EMPTY_SWITCH_DEFAULT_CASE()
+	if (zend_hash_index_find(&list_destructors,le->type,(void **) &ld)==SUCCESS) {
+		if (ld->list_destructor) {
+			(ld->list_destructor)(le->ptr);
 		}
 	} else {
 		zend_error(E_WARNING,"Unknown list entry type in request shutdown (%d)",le->type);
 	}
+	return 1;
 }


-void plist_entry_destructor(void *ptr)
+int plist_entry_destructor(void *ptr)
 {
-	zend_rsrc_list_entry *le = (zend_rsrc_list_entry *) ptr;
-	zend_rsrc_list_dtors_entry *ld;
+	list_entry *le = (list_entry *) ptr;
+	list_destructors_entry *ld;

-	if (zend_hash_index_find(&list_destructors, le->type,(void **) &ld)==SUCCESS) {
-		if (ld->plist_dtor) {
-			(ld->plist_dtor)(le->ptr);
+	if (zend_hash_index_find(&list_destructors,le->type,(void **) &ld)==SUCCESS) {
+		if (ld->plist_destructor) {
+			(ld->plist_destructor)(le->ptr);
 		}
 	} else {
 		zend_error(E_WARNING,"Unknown persistent list entry type in module shutdown (%d)",le->type);
 	}
+	return 1;
 }


-int zend_init_rsrc_list(ELS_D)
+int init_resource_list(ELS_D)
 {
 	return zend_hash_init(&EG(regular_list), 0, NULL, list_entry_destructor, 0);
 }


-int zend_init_rsrc_plist(ELS_D)
+int init_resource_plist(ELS_D)
 {
-	return zend_hash_init_ex(&EG(persistent_list), 0, NULL, plist_entry_destructor, 1, 0);
+	return zend_hash_init(&EG(persistent_list), 0, NULL, plist_entry_destructor, 1);
 }


-void zend_destroy_rsrc_list(ELS_D)
+void destroy_resource_list(void)
 {
-	zend_hash_graceful_destroy(&EG(regular_list));
+	ELS_FETCH();
+
+	zend_hash_destroy(&EG(regular_list));
 }


-void zend_destroy_rsrc_plist(ELS_D)
+void destroy_resource_plist(void)
 {
-	zend_hash_graceful_destroy(&EG(persistent_list));
+	ELS_FETCH();
+
+	zend_hash_destroy(&EG(persistent_list));
 }


-static int clean_module_resource(zend_rsrc_list_entry *le, int *resource_id)
+static int clean_module_resource(list_entry *le, int *resource_id)
 {
 	if (le->type == *resource_id) {
 		return 1;
@@ -315,12 +274,11 @@ static int clean_module_resource(zend_rsrc_list_entry *le, int *resource_id)
 }


-static int zend_clean_module_rsrc_dtors_cb(zend_rsrc_list_dtors_entry *ld, int *module_number)
+int clean_module_resource_destructors(list_destructors_entry *ld, int *module_number)
 {
 	if (ld->module_number == *module_number) {
 		ELS_FETCH();

-		zend_hash_apply_with_argument(&EG(regular_list), (int (*)(void *,void *)) clean_module_resource, (void *) &(ld->resource_id));
 		zend_hash_apply_with_argument(&EG(persistent_list), (int (*)(void *,void *)) clean_module_resource, (void *) &(ld->resource_id));
 		return 1;
 	} else {
@@ -329,87 +287,6 @@ static int zend_clean_module_rsrc_dtors_cb(zend_rsrc_list_dtors_entry *ld, int *
 }


-void zend_clean_module_rsrc_dtors(int module_number)
-{
-	zend_hash_apply_with_argument(&list_destructors, (int (*)(void *,void *)) zend_clean_module_rsrc_dtors_cb, (void *) &module_number);
-}
-
-
-ZEND_API int zend_register_list_destructors(void (*ld)(void *), void (*pld)(void *), int module_number)
-{
-	zend_rsrc_list_dtors_entry lde;
-	
-#if 0
-	printf("Registering destructors %d for module %d\n", list_destructors.nNextFreeElement, module_number);
-#endif
-	
-	lde.list_dtor=(void (*)(void *)) ld;
-	lde.plist_dtor=(void (*)(void *)) pld;
-	lde.list_dtor_ex = lde.plist_dtor_ex = NULL;
-	lde.module_number = module_number;
-	lde.resource_id = list_destructors.nNextFreeElement;
-	lde.type = ZEND_RESOURCE_LIST_TYPE_STD;
-	lde.type_name = NULL;
-	
-	if (zend_hash_next_index_insert(&list_destructors, (void *) &lde, sizeof(zend_rsrc_list_dtors_entry), NULL)==FAILURE) {
-		return FAILURE;
-	}
-	return list_destructors.nNextFreeElement-1;
-}
-
-
-ZEND_API int zend_register_list_destructors_ex(rsrc_dtor_func_t ld, rsrc_dtor_func_t pld, char *type_name, int module_number)
-{
-	zend_rsrc_list_dtors_entry lde;
-	
-#if 0
-	printf("Registering destructors %d for module %d\n", list_destructors.nNextFreeElement, module_number);
-#endif
-
-	lde.list_dtor = NULL;
-	lde.plist_dtor = NULL;
-	lde.list_dtor_ex = ld;
-	lde.plist_dtor_ex = pld;
-	lde.module_number = module_number;
-	lde.resource_id = list_destructors.nNextFreeElement;
-	lde.type = ZEND_RESOURCE_LIST_TYPE_EX;
-	lde.type_name = type_name;
-	
-	if (zend_hash_next_index_insert(&list_destructors,(void *) &lde, sizeof(zend_rsrc_list_dtors_entry),NULL)==FAILURE) {
-		return FAILURE;
-	}
-	return list_destructors.nNextFreeElement-1;
-}
-
-
-int zend_init_rsrc_list_dtors()
-{
-	return zend_hash_init(&list_destructors, 50, NULL, NULL, 1);
-}
-
-
-void zend_destroy_rsrc_list_dtors()
-{
-	zend_hash_destroy(&list_destructors);
-}
-
-
-char *zend_rsrc_list_get_rsrc_type(int resource)
-{
-	zend_rsrc_list_dtors_entry *lde;
-	int rsrc_type;
-
-	if (!zend_list_find(resource, &rsrc_type))
-		return NULL;
-
-	if (zend_hash_index_find(&list_destructors, rsrc_type, (void **) &lde)==SUCCESS) {
-		return lde->type_name;
-	} else {
-		return NULL;
-	}
-}
-
-
 /*
 * Local variables:
 * tab-width: 4
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -18,81 +18,59 @@
 */


-#ifndef ZEND_LIST_H
-#define ZEND_LIST_H
+#ifndef _LIST_H
+#define _LIST_H

 #include "zend_hash.h"
 #include "zend_globals.h"

+extern HashTable list_destructors;

-#define ZEND_RESOURCE_LIST_TYPE_STD	1
-#define ZEND_RESOURCE_LIST_TYPE_EX	2
-
-typedef struct _zend_rsrc_list_entry {
+typedef struct _list_entry {
 	void *ptr;
 	int type;
 	int refcount;
-	zend_bool valid;
-} zend_rsrc_list_entry;
-
-typedef void (*rsrc_dtor_func_t)(zend_rsrc_list_entry *rsrc);
-#define ZEND_RSRC_DTOR_FUNC(name)		void name(zend_rsrc_list_entry *rsrc)
-
-typedef struct _zend_rsrc_list_dtors_entry {
-	/* old style destructors */
-	void (*list_dtor)(void *);
-	void (*plist_dtor)(void *);
-
-	/* new style destructors */
-	rsrc_dtor_func_t list_dtor_ex;
-	rsrc_dtor_func_t plist_dtor_ex;
-
-	char *type_name;
+} list_entry;

+typedef struct _list_destructors_entry {
+	void (*list_destructor)(void *);
+	void (*plist_destructor)(void *);
 	int module_number;
 	int resource_id;
-	unsigned char type;
-} zend_rsrc_list_dtors_entry;
+} list_destructors_entry;

-
-#define register_list_destructors(ld, pld) zend_register_list_destructors((void (*)(void *))ld, (void (*)(void *))pld, module_number);
-ZEND_API int zend_register_list_destructors(void (*ld)(void *), void (*pld)(void *), int module_number);
-ZEND_API int zend_register_list_destructors_ex(rsrc_dtor_func_t ld, rsrc_dtor_func_t pld, char *type_name, int module_number);
+#define register_list_destructors(ld,pld) _register_list_destructors((void (*)(void *))ld, (void (*)(void *))pld, module_number);
+ZEND_API int _register_list_destructors(void (*ld)(void *), void (*pld)(void *), int module_number);

 enum list_entry_type {
 	LE_DB=1000
 };

-void list_entry_destructor(void *ptr);
-void plist_entry_destructor(void *ptr);
+int list_entry_destructor(void *ptr);
+int plist_entry_destructor(void *ptr);

-void zend_clean_module_rsrc_dtors(int module_number);
-int zend_init_rsrc_list(ELS_D);
-int zend_init_rsrc_plist(ELS_D);
-void zend_destroy_rsrc_list(ELS_D);
-void zend_destroy_rsrc_plist(ELS_D);
-int zend_init_rsrc_list_dtors();
-void zend_destroy_rsrc_list_dtors();
+int clean_module_resource_destructors(list_destructors_entry *ld, int *module_number);
+int init_resource_list(ELS_D);
+int init_resource_plist(ELS_D);
+void destroy_resource_list(void);
+void destroy_resource_plist(void);

 ZEND_API int zend_list_insert(void *ptr, int type);
 ZEND_API int zend_plist_insert(void *ptr, int type);
 ZEND_API int zend_list_addref(int id);
 ZEND_API int zend_list_delete(int id);
 ZEND_API int zend_plist_delete(int id);
-ZEND_API int zend_list_convert_to_number(int id);
 ZEND_API void *zend_list_find(int id, int *type);
 ZEND_API void *zend_plist_find(int id, int *type);

 ZEND_API int zend_register_resource(zval *rsrc_result, void *rsrc_pointer, int rsrc_type);
 ZEND_API void *zend_fetch_resource(zval **passed_id, int default_id, char *resource_type_name, int *found_resource_type, int num_resource_types, ...);

-ZEND_API char *zend_rsrc_list_get_rsrc_type(int resource);
-
 extern ZEND_API int le_index_ptr;  /* list entry type for index pointers */

 #define ZEND_VERIFY_RESOURCE(rsrc)		\
 	if (!rsrc) {						\
-		RETURN_NULL();					\
+		RETURN_FALSE;					\
 	}

 #define ZEND_FETCH_RESOURCE(rsrc, rsrc_type, passed_id, default_id, resource_type_name, resource_type)	\
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -63,30 +63,26 @@ ZEND_API void zend_llist_prepend_element(zend_llist *l, void *element)
 }


-#define DEL_LLIST_ELEMENT(current,l) \
-			if (current->prev) {\
-				current->prev->next = current->next;\
-			} else {\
-				l->head = current->next;\
-			}\
-			if (current->next) {\
-				current->next->prev = current->prev;\
-			} else {\
-				l->tail = current->prev;\
-			}\
-			if (l->dtor) {\
-				l->dtor(current->data);\
-				pefree(current, l->persistent);\
-			}
-
-
-ZEND_API void zend_llist_del_element(zend_llist *l, void *element, int (*compare)(void *element1, void *element2))
+ZEND_API void zend_llist_del_element(zend_llist *l, void *element)
 {
 	zend_llist_element *current=l->head;

 	while (current) {
-		if (compare(current->data, element)) {
-			DEL_LLIST_ELEMENT(current,l);
+		if (!memcmp(current->data, element, l->size)) {
+			if (current->prev) {
+				current->prev->next = current->next;
+			} else {
+				l->head = current->next;
+			}
+			if (current->next) {
+				current->next->prev = current->prev;
+			} else {
+				l->tail = current->prev;
+			}
+			if (l->dtor) {
+				l->dtor(current->data);
+				efree(current);
+			}
 			break;
 		}
 		current = current->next;
@@ -125,7 +121,7 @@ ZEND_API void zend_llist_remove_tail(zend_llist *l)
 			l->tail->prev->next = NULL;
 		}
 		l->tail = l->tail->prev;
-		pefree(old_tail, l->persistent);
+		efree(old_tail);
 	}
 }

@@ -143,21 +139,6 @@ ZEND_API void zend_llist_copy(zend_llist *dst, zend_llist *src)
 }


-ZEND_API void zend_llist_apply_with_del(zend_llist *l, int (*func)(void *data))
-{
-	zend_llist_element *element, *next;
-
-	element=l->head;
-	while (element) {
-		next = element->next;
-		if (func(element->data)) {
-			DEL_LLIST_ELEMENT(element,l);
-		}
-		element = next;
-	}
-}
-
-
 ZEND_API void zend_llist_apply(zend_llist *l, void (*func)(void *data))
 {
 	zend_llist_element *element;
@@ -167,43 +148,6 @@ ZEND_API void zend_llist_apply(zend_llist *l, void (*func)(void *data))
 	}
 }

-ZEND_API void zend_llist_sort(zend_llist *l, llist_compare_func_t comp_func)
-{
-	int list_size=0, i;
-
-	zend_llist_element **elements;
-	zend_llist_element *element, **ptr;
-
-	for (element=l->head; element; element=element->next) {
-		list_size++;
-	}
-
-	if (list_size == 0) {
-		return;
-	}
-
-	elements = (zend_llist_element **) emalloc(list_size*sizeof(zend_llist_element *));
-
-	ptr = &elements[0];
-
-	for (element=l->head; element; element=element->next) {
-		*ptr++ = element;
-	}
-
-	qsort(elements, list_size, sizeof(zend_llist_element *), (int (*)(const void *, const void *)) comp_func);
-
-	l->head = elements[0];
-	elements[0]->prev = NULL;
-
-	for (i=1; i<list_size; i++) {
-		elements[i]->prev = elements[i-1];
-		elements[i-1]->next = elements[i];
-	}
-	elements[i-1]->next = NULL;
-	l->tail = elements[i-1];
-	efree(elements);
-}
-

 ZEND_API void zend_llist_apply_with_argument(zend_llist *l, void (*func)(void *data, void *arg), void *arg)
 {
@@ -215,19 +159,6 @@ ZEND_API void zend_llist_apply_with_argument(zend_llist *l, void (*func)(void *d
 }


-ZEND_API void zend_llist_apply_with_arguments(zend_llist *l, llist_apply_with_args_func_t func, int num_args, ...)
-{
-	zend_llist_element *element;
-	va_list args;
-
-	va_start(args, num_args);
-	for (element=l->head; element; element=element->next) {
-		func(element->data, num_args, args);
-	}
-	va_end(args);
-}
-
-
 ZEND_API int zend_llist_count(zend_llist *l)
 {
 	zend_llist_element *element;
@@ -240,54 +171,46 @@ ZEND_API int zend_llist_count(zend_llist *l)
 }


-ZEND_API void *zend_llist_get_first_ex(zend_llist *l, zend_llist_position *pos)
+ZEND_API void *zend_llist_get_first(zend_llist *l)
 {
-	zend_llist_position *current = pos ? pos : &l->traverse_ptr;
-
-	*current = l->head;
-	if (*current) {
-		return (*current)->data;
+	l->traverse_ptr = l->head;
+	if (l->traverse_ptr) {
+		return l->traverse_ptr->data;
 	} else {
 		return NULL;
 	}
 }


-ZEND_API void *zend_llist_get_last_ex(zend_llist *l, zend_llist_position *pos)
+ZEND_API void *zend_llist_get_last(zend_llist *l)
 {
-	zend_llist_position *current = pos ? pos : &l->traverse_ptr;
-
-	*current = l->tail;
-	if (*current) {
-		return (*current)->data;
+	l->traverse_ptr = l->tail;
+	if (l->traverse_ptr) {
+		return l->traverse_ptr->data;
 	} else {
 		return NULL;
 	}
 }


-ZEND_API void *zend_llist_get_next_ex(zend_llist *l, zend_llist_position *pos)
+ZEND_API void *zend_llist_get_next(zend_llist *l)
 {
-	zend_llist_position *current = pos ? pos : &l->traverse_ptr;
-
-	if (*current) {
-		*current = (*current)->next;
-		if (*current) {
-			return (*current)->data;
+	if (l->traverse_ptr) {
+		l->traverse_ptr = l->traverse_ptr->next;
+		if (l->traverse_ptr) {
+			return l->traverse_ptr->data;
 		}
 	}
 	return NULL;
 }


-ZEND_API void *zend_llist_get_prev_ex(zend_llist *l, zend_llist_position *pos)
+ZEND_API void *zend_llist_get_prev(zend_llist *l)
 {
-	zend_llist_position *current = pos ? pos : &l->traverse_ptr;
-
-	if (*current) {
-		*current = (*current)->prev;
-		if (*current) {
-			return (*current)->data;
+	if (l->traverse_ptr) {
+		l->traverse_ptr = l->traverse_ptr->prev;
+		if (l->traverse_ptr) {
+			return l->traverse_ptr->data;
 		}
 	}
 	return NULL;
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -18,8 +18,8 @@
 */


-#ifndef ZEND_LLIST_H
-#define ZEND_LLIST_H
+#ifndef _ZEND_LLIST_H
+#define _ZEND_LLIST_H

 #include <stdlib.h>

@@ -38,40 +38,24 @@ typedef struct _zend_llist {
 	zend_llist_element *traverse_ptr;
 } zend_llist;

-typedef int (*llist_compare_func_t)(const zend_llist_element *, const zend_llist_element *);
-typedef void(*llist_apply_with_arg_func_t)(void *data, void *arg);
-typedef void(*llist_apply_with_args_func_t)(void *data, int num_args, va_list args);
-typedef void (*llist_apply_func_t)(void *);
-
-typedef zend_llist_element* zend_llist_position;
-
 BEGIN_EXTERN_C()
 ZEND_API void zend_llist_init(zend_llist *l, size_t size, void (*dtor)(void *data), unsigned char persistent);
 ZEND_API void zend_llist_add_element(zend_llist *l, void *element);
 ZEND_API void zend_llist_prepend_element(zend_llist *l, void *element);
-ZEND_API void zend_llist_del_element(zend_llist *l, void *element, int (*compare)(void *element1, void *element2));
+ZEND_API void zend_llist_del_element(zend_llist *l, void *element);
 ZEND_API void zend_llist_destroy(zend_llist *l);
 ZEND_API void zend_llist_clean(zend_llist *l);
 ZEND_API void zend_llist_remove_tail(zend_llist *l);
 ZEND_API void zend_llist_copy(zend_llist *dst, zend_llist *src);
-ZEND_API void zend_llist_apply(zend_llist *l, llist_apply_func_t);
-ZEND_API void zend_llist_apply_with_del(zend_llist *l, int (*func)(void *data));
-ZEND_API void zend_llist_apply_with_argument(zend_llist *l, llist_apply_with_arg_func_t, void *arg);
-ZEND_API void zend_llist_apply_with_arguments(zend_llist *l, llist_apply_with_args_func_t func, int num_args, ...);
+ZEND_API void zend_llist_apply(zend_llist *l, void (*func)(void *data));
+ZEND_API void zend_llist_apply_with_argument(zend_llist *l, void (*func)(void *data, void *arg), void *arg);
 ZEND_API int zend_llist_count(zend_llist *l);
-ZEND_API void zend_llist_sort(zend_llist *l, llist_compare_func_t comp_func);

 /* traversal */
-ZEND_API void *zend_llist_get_first_ex(zend_llist *l, zend_llist_position *pos);
-ZEND_API void *zend_llist_get_last_ex(zend_llist *l, zend_llist_position *pos);
-ZEND_API void *zend_llist_get_next_ex(zend_llist *l, zend_llist_position *pos);
-ZEND_API void *zend_llist_get_prev_ex(zend_llist *l, zend_llist_position *pos);
-
-#define zend_llist_get_first(l) zend_llist_get_first_ex(l, NULL)
-#define zend_llist_get_last(l) zend_llist_get_last_ex(l, NULL)
-#define zend_llist_get_next(l) zend_llist_get_next_ex(l, NULL)
-#define zend_llist_get_prev(l) zend_llist_get_prev_ex(l, NULL)
-
+ZEND_API void *zend_llist_get_first(zend_llist *l);
+ZEND_API void *zend_llist_get_last(zend_llist *l);
+ZEND_API void *zend_llist_get_next(zend_llist *l);
+ZEND_API void *zend_llist_get_prev(zend_llist *l);
 END_EXTERN_C()

-#endif /* ZEND_LLIST_H */
+#endif /* _ZEND_LLIST_H */
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -18,33 +18,16 @@
 */


-#ifndef MODULES_H
-#define MODULES_H
+#ifndef _MODULES_H
+#define _MODULES_H

-#define INIT_FUNC_ARGS		int type, int module_number ELS_DC
-#define INIT_FUNC_ARGS_PASSTHRU	type, module_number ELS_CC
+#define INIT_FUNC_ARGS		int type, int module_number
+#define INIT_FUNC_ARGS_PASSTHRU	type, module_number
 #define SHUTDOWN_FUNC_ARGS	int type, int module_number
 #define SHUTDOWN_FUNC_ARGS_PASSTHRU type, module_number
 #define ZEND_MODULE_INFO_FUNC_ARGS zend_module_entry *zend_module
-#define ZEND_MODULE_INFO_FUNC_ARGS_PASSTHRU zend_module
-#define GINIT_FUNC_ARGS		void
-#define GINIT_FUNC_ARGS_PASSTHRU

-extern unsigned char first_arg_force_ref[];
-extern unsigned char first_arg_allow_ref[];
-extern unsigned char second_arg_force_ref[];
-extern unsigned char second_arg_allow_ref[];
-
-#include "zend.h"
-
-#define ZEND_MODULE_API_NO 20000809
-#ifdef ZTS
-#define USING_ZTS 1
-#else
-#define USING_ZTS 0
-#endif
-
-#define STANDARD_MODULE_PROPERTIES_EX 0, 0, 0, NULL, 0, ZEND_DEBUG, USING_ZTS, ZEND_MODULE_API_NO
+#define STANDARD_MODULE_PROPERTIES_EX 0, 0, 0, NULL, 0

 #define STANDARD_MODULE_PROPERTIES \
 	NULL, NULL, STANDARD_MODULE_PROPERTIES_EX
@@ -64,22 +47,18 @@ struct _zend_module_entry {
 	void (*info_func)(ZEND_MODULE_INFO_FUNC_ARGS);
 	int (*global_startup_func)(void);
 	int (*global_shutdown_func)(void);
-	int globals_id;
-	int module_started;
+	int request_started, module_started;
 	unsigned char type;
 	void *handle;
 	int module_number;
-	unsigned char zend_debug;
-	unsigned char zts;
-	unsigned int zend_api;
 };


-extern ZEND_API HashTable module_registry;
+extern HashTable module_registry;

 void module_destructor(zend_module_entry *module);
 int module_registry_cleanup(zend_module_entry *module);
 int module_registry_request_startup(zend_module_entry *module);

-#define ZEND_MODULE_DTOR (void (*)(void *)) module_destructor
+#define ZEND_MODULE_DTOR (int (*)(void *)) module_destructor
 #endif
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -23,6 +23,8 @@
 #include "zend.h"
 #include "zend_alloc.h"
 #include "zend_compile.h"
+#include "zend_variables.h"
+#include "zend_operators.h"
 #include "zend_extensions.h"
 #include "zend_API.h"

@@ -30,7 +32,11 @@
 static void zend_extension_op_array_ctor_handler(zend_extension *extension, zend_op_array *op_array)
 {
 	if (extension->op_array_ctor) {
-		extension->op_array_ctor(op_array);
+		if (extension->resource_number>=0) {
+			extension->op_array_ctor(&op_array->reserved[extension->resource_number]);
+		} else {
+			extension->op_array_ctor(NULL);
+		}
 	}
 }

@@ -38,7 +44,11 @@ static void zend_extension_op_array_ctor_handler(zend_extension *extension, zend
 static void zend_extension_op_array_dtor_handler(zend_extension *extension, zend_op_array *op_array)
 {
 	if (extension->op_array_dtor) {
-		extension->op_array_dtor(op_array);
+		if (extension->resource_number>=0) {
+			extension->op_array_dtor(&op_array->reserved[extension->resource_number]);
+		} else {
+			extension->op_array_dtor(NULL);
+		}
 	}
 }

@@ -50,9 +60,9 @@ static void op_array_alloc_ops(zend_op_array *op_array)



-void init_op_array(zend_op_array *op_array, int type, int initial_ops_size CLS_DC)
+void init_op_array(zend_op_array *op_array, int initial_ops_size)
 {
-	op_array->type = type;
+	op_array->type = ZEND_USER_FUNCTION;
 #if SUPPORT_INTERACTIVE
 	{
 		ELS_FETCH();
@@ -68,7 +78,7 @@ void init_op_array(zend_op_array *op_array, int type, int initial_ops_size CLS_D
 	}
 #endif

-	op_array->refcount = (zend_uint *) emalloc(sizeof(zend_uint));
+	op_array->refcount = (int *) emalloc(sizeof(int));
 	*op_array->refcount = 1;
 	op_array->size = initial_ops_size;
 	op_array->last = 0;
@@ -78,7 +88,6 @@ void init_op_array(zend_op_array *op_array, int type, int initial_ops_size CLS_D
 	op_array->T = 0;

 	op_array->function_name = NULL;
-	op_array->filename = zend_get_compiled_filename(CLS_C);

 	op_array->arg_types = NULL;

@@ -90,14 +99,11 @@ void init_op_array(zend_op_array *op_array, int type, int initial_ops_size CLS_D

 	op_array->uses_globals = 0;

-	op_array->return_reference = 0;
-	op_array->done_pass_two = 0;
-
 	zend_llist_apply_with_argument(&zend_extensions, (void (*)(void *, void *)) zend_extension_op_array_ctor_handler, op_array);
 }


-ZEND_API void destroy_zend_function(zend_function *function)
+ZEND_API int destroy_zend_function(zend_function *function)
 {
 	switch (function->type) {
 		case ZEND_USER_FUNCTION:
@@ -107,13 +113,14 @@ ZEND_API void destroy_zend_function(zend_function *function)
 			/* do nothing */
 			break;
 	}
+	return 1;
 }


-ZEND_API void destroy_zend_class(zend_class_entry *ce)
+ZEND_API int destroy_zend_class(zend_class_entry *ce)
 {
 	if (--(*ce->refcount)>0) {
-		return;
+		return 1;
 	}
 	switch (ce->type) {
 		case ZEND_USER_CLASS:
@@ -129,6 +136,7 @@ ZEND_API void destroy_zend_class(zend_class_entry *ce)
 			zend_hash_destroy(&ce->default_properties);
 			break;
 	}
+	return 1;
 }


@@ -143,11 +151,6 @@ ZEND_API void destroy_op_array(zend_op_array *op_array)
 	zend_op *opline = op_array->opcodes;
 	zend_op *end = op_array->opcodes+op_array->last;

-	if (op_array->static_variables) {
-		zend_hash_destroy(op_array->static_variables);
-		FREE_HASHTABLE(op_array->static_variables);
-	}
-
 	if (--(*op_array->refcount)>0) {
 		return;
 	}
@@ -179,25 +182,31 @@ ZEND_API void destroy_op_array(zend_op_array *op_array)
 	if (op_array->brk_cont_array) {
 		efree(op_array->brk_cont_array);
 	}
-	if (op_array->done_pass_two) {
-		zend_llist_apply_with_argument(&zend_extensions, (void (*)(void *, void *)) zend_extension_op_array_dtor_handler, op_array);
+	if (op_array->static_variables) {
+		zend_hash_destroy(op_array->static_variables);
+		efree(op_array->static_variables);
 	}
+	zend_llist_apply_with_argument(&zend_extensions, (void (*)(void *, void *)) zend_extension_op_array_dtor_handler, op_array);
 }


 void init_op(zend_op *op CLS_DC)
 {
-	memset(&op->result, 0, sizeof(znode));
 	op->lineno = CG(zend_lineno);
-	SET_UNUSED(op->result);
+	op->filename = zend_get_compiled_filename();
+	op->result.op_type = IS_UNUSED;
 	op->extended_value = 0;
-	memset(&op->op1, 0, sizeof(znode));
-	memset(&op->op2, 0, sizeof(znode));
+	op->op1.u.EA.var = 0;
+	op->op1.u.EA.type = 0;
+	op->op2.u.EA.var = 0;
+	op->op2.u.EA.type = 0;
+	op->result.u.EA.var = 0;
+	op->result.u.EA.type = 0;
 }

 zend_op *get_next_op(zend_op_array *op_array CLS_DC)
 {
-	zend_uint next_op_num = op_array->last++;
+	int next_op_num = op_array->last++;
 	zend_op *next_op;

 	if (next_op_num >= op_array->size) {
@@ -211,7 +220,7 @@ zend_op *get_next_op(zend_op_array *op_array CLS_DC)
 			zend_bailout();
 		}
 #endif
-		op_array->size *= 4;
+		op_array->size *= 2;
 		op_array_alloc_ops(op_array);
 	}
 	
@@ -252,6 +261,7 @@ static void zend_update_extended_info(zend_op_array *op_array CLS_DC)
 					continue;
 				}
 				opline->lineno = (opline+1)->lineno;
+				opline->filename = (opline+1)->filename;
 			} else {
 				opline->opcode = ZEND_NOP;
 			}
@@ -260,9 +270,10 @@ static void zend_update_extended_info(zend_op_array *op_array CLS_DC)
 	}
 	opline = get_next_op(op_array CLS_CC);
 	opline->opcode = ZEND_EXT_STMT;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
+	opline->op1.op_type = IS_UNUSED;
+	opline->op2.op_type = IS_UNUSED;
 	if (op_array->last>0) {
+		opline->filename = op_array->opcodes[op_array->last-2].filename;
 		opline->lineno= op_array->opcodes[op_array->last-2].lineno;
 	}
 }
@@ -279,7 +290,6 @@ static void zend_extension_op_array_handler(zend_extension *extension, zend_op_a

 int pass_two(zend_op_array *op_array)
 {
-	zend_op *opline=op_array->opcodes, *end=opline+op_array->last;
 	CLS_FETCH();

 	if (op_array->type!=ZEND_USER_FUNCTION && op_array->type!=ZEND_EVAL_CODE) {
@@ -291,21 +301,23 @@ int pass_two(zend_op_array *op_array)
 	if (CG(handle_op_arrays)) {
 		zend_llist_apply_with_argument(&zend_extensions, (void (*)(void *, void *)) zend_extension_op_array_handler, op_array);
 	}
+	return 0;
+}
+
+
+void pass_include_eval(zend_op_array *op_array)
+{
+	zend_op *opline=op_array->opcodes, *end=opline+op_array->last;
+
 	while (opline<end) {
 		if (opline->op1.op_type==IS_CONST) {
 			opline->op1.u.constant.is_ref = 1;
-			opline->op1.u.constant.refcount = 2; /* Make sure is_ref won't be reset */
 		}
 		if (opline->op2.op_type==IS_CONST) {
 			opline->op2.u.constant.is_ref = 1;
-			opline->op2.u.constant.refcount = 2;
 		}
 		opline++;
 	}
-	op_array->opcodes = (zend_op *) erealloc(op_array->opcodes, sizeof(zend_op)*op_array->last);
-	op_array->size = op_array->last;
-	op_array->done_pass_two = 1;
-	return 0;
 }


@@ -371,9 +383,6 @@ ZEND_API void *get_binary_op(int opcode)
 		case ZEND_IS_IDENTICAL:
 			return (void *) is_identical_function;
 			break;
-		case ZEND_IS_NOT_IDENTICAL:
-			return (void *) is_not_identical_function;
-			break;
 		case ZEND_IS_EQUAL:
 			return (void *) is_equal_function;
 			break;
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -18,20 +18,8 @@
 */


-#ifndef ZEND_OPERATORS_H
-#define ZEND_OPERATORS_H
-
-#include <errno.h>
-#include <math.h>
-
-#ifdef HAVE_IEEEFP_H
-#include <ieeefp.h>
-#endif
-
-
-#if 0&&WITH_BCMATH
-#include "ext/bcmath/libbcmath/src/bcmath.h"
-#endif
+#ifndef _OPERATORS_H
+#define _OPERATORS_H

 #define MAX_LENGTH_OF_LONG 18
 #define MAX_LENGTH_OF_DOUBLE 32
@@ -55,143 +43,82 @@ ZEND_API int concat_function(zval *result, zval *op1, zval *op2);

 ZEND_API int is_equal_function(zval *result, zval *op1, zval *op2);
 ZEND_API int is_identical_function(zval *result, zval *op1, zval *op2);
-ZEND_API int is_not_identical_function(zval *result, zval *op1, zval *op2);
 ZEND_API int is_not_equal_function(zval *result, zval *op1, zval *op2);
 ZEND_API int is_smaller_function(zval *result, zval *op1, zval *op2);
 ZEND_API int is_smaller_or_equal_function(zval *result, zval *op1, zval *op2);
-static inline int is_numeric_string(char *str, int length, long *lval, double *dval)
-{
-	long local_lval;
-	double local_dval;
-	char *end_ptr;
-
-	if (!length) {
-		return 0;
-	}
-	
-	errno=0;
-	local_lval = strtol(str, &end_ptr, 10);
-	if (errno!=ERANGE && end_ptr == str+length) { /* integer string */
-		if (lval) {
-			*lval = local_lval;
-		}
-		return IS_LONG;
-	}
-
-	errno=0;
-	local_dval = strtod(str, &end_ptr);
-	if (errno!=ERANGE && end_ptr == str+length) { /* floating point string */
-		if (! zend_finite(local_dval)) {
-			/* "inf","nan" and maybe other weird ones */
-			return 0;
-		}
-
-		if (dval) {
-			*dval = local_dval;
-		}
-#if 0&&WITH_BCMATH
-		if (length>16) {
-			register char *ptr=str, *end=str+length;
-			
-			while(ptr<end) {
-				switch(*ptr++) {
-					case 'e':
-					case 'E':
-						/* scientific notation, not handled by the BC library */
-						return IS_DOUBLE;
-						break;
-					default:
-						break;
-				}
-			}
-			return FLAG_IS_BC;
-		} else {
-			return IS_DOUBLE;
-		}
-#else
-		return IS_DOUBLE;
-#endif
-	}
-	
-	return 0;
-}
+ZEND_API inline int is_numeric_string(char *str, int length, long *lval, double *dval);

 ZEND_API int increment_function(zval *op1);
 ZEND_API int decrement_function(zval *op2);

 BEGIN_EXTERN_C()
 ZEND_API void convert_scalar_to_number(zval *op);
-ZEND_API void _convert_to_string(zval *op ZEND_FILE_LINE_DC);
+ZEND_API void convert_to_string(zval *op);
 ZEND_API void convert_to_long(zval *op);
-ZEND_API void convert_to_double(zval *op);
 ZEND_API void convert_to_long_base(zval *op, int base);
-ZEND_API void convert_to_null(zval *op);
 ZEND_API void convert_to_boolean(zval *op);
 ZEND_API void convert_to_array(zval *op);
 ZEND_API void convert_to_object(zval *op);
-ZEND_API void multi_convert_to_long_ex(int argc, ...);
-ZEND_API void multi_convert_to_double_ex(int argc, ...);
-ZEND_API void multi_convert_to_string_ex(int argc, ...);
 ZEND_API int add_char_to_string(zval *result, zval *op1, zval *op2);
 ZEND_API int add_string_to_string(zval *result, zval *op1, zval *op2);
-#define convert_to_string(op)			_convert_to_string((op) ZEND_FILE_LINE_CC)
-
-ZEND_API double zend_string_to_double(const char *number, zend_uint length);
+ZEND_API void convert_to_double(zval *op);
 END_EXTERN_C()

 ZEND_API int zval_is_true(zval *op);
 ZEND_API int compare_function(zval *result, zval *op1, zval *op2);
-ZEND_API int numeric_compare_function(zval *result, zval *op1, zval *op2);
-ZEND_API int string_compare_function(zval *result, zval *op1, zval *op2);

 ZEND_API void zend_str_tolower(char *str, unsigned int length);
-ZEND_API int zend_binary_zval_strcmp(zval *s1, zval *s2);
-ZEND_API int zend_binary_zval_strncmp(zval *s1, zval *s2, zval *s3);
-ZEND_API int zend_binary_zval_strcasecmp(zval *s1, zval *s2);
-ZEND_API int zend_binary_zval_strncasecmp(zval *s1, zval *s2, zval *s3);
-ZEND_API int zend_binary_strcmp(char *s1, uint len1, char *s2, uint len2);
-ZEND_API int zend_binary_strncmp(char *s1, uint len1, char *s2, uint len2, uint length);
-ZEND_API int zend_binary_strcasecmp(char *s1, uint len1, char *s2, uint len2);
-ZEND_API int zend_binary_strncasecmp(char *s1, uint len1, char *s2, uint len2, uint length);
-
+ZEND_API int zend_binary_strcmp(zval *s1, zval *s2);
+ZEND_API int zend_binary_strcasecmp(zval *s1, zval *s2);
 ZEND_API void zendi_smart_strcmp(zval *result, zval *s1, zval *s2);
-ZEND_API void zend_compare_symbol_tables(zval *result, HashTable *ht1, HashTable *ht2);
-ZEND_API void zend_compare_arrays(zval *result, zval *a1, zval *a2);
-ZEND_API void zend_compare_objects(zval *result, zval *o1, zval *o2);

-ZEND_API int zend_atoi(const char *str, int str_len);
-
-#define convert_to_ex_master(ppzv, lower_type, upper_type)	\
-	if ((*ppzv)->type!=IS_##upper_type) {					\
-		if (!(*ppzv)->is_ref) {								\
+#define convert_to_long_ex(ppzv)							\
+	if ((*ppzv)->type!=IS_LONG) {							\
+		if (!(*ppzv)->is_ref) {							\
 			SEPARATE_ZVAL(ppzv);							\
 		}													\
-		convert_to_##lower_type(*ppzv);						\
+		convert_to_long(*ppzv);								\
 	}

-#define convert_to_writable_ex_master(ppzv, lower_type, upper_type)	\
-	if ((*ppzv)->type!=IS_##upper_type) {							\
-		SEPARATE_ZVAL(ppzv);										\
-		convert_to_##lower_type(*ppzv);								\
+#define convert_to_double_ex(ppzv)							\
+	if ((*ppzv)->type!=IS_DOUBLE) {							\
+		if (!(*ppzv)->is_ref) {							\
+			SEPARATE_ZVAL(ppzv);							\
+		}													\
+		convert_to_double(*ppzv);							\
 	}

+#define convert_to_string_ex(ppzv)							\
+	if ((*ppzv)->type!=IS_STRING) {							\
+		if (!(*ppzv)->is_ref) {							\
+			SEPARATE_ZVAL(ppzv);							\
+		}													\
+		convert_to_string(*ppzv);							\
+	}

-#define convert_to_boolean_ex(ppzv)	convert_to_ex_master(ppzv, boolean, BOOL)
-#define convert_to_long_ex(ppzv)	convert_to_ex_master(ppzv, long, LONG)
-#define convert_to_double_ex(ppzv)	convert_to_ex_master(ppzv, double, DOUBLE)
-#define convert_to_string_ex(ppzv)	convert_to_ex_master(ppzv, string, STRING)
-#define convert_to_array_ex(ppzv)	convert_to_ex_master(ppzv, array, ARRAY)
-#define convert_to_object_ex(ppzv)	convert_to_ex_master(ppzv, object, OBJECT)
-#define convert_to_null_ex(ppzv)	convert_to_ex_master(ppzv, null, NULL)
+#define convert_to_array_ex(ppzv)							\
+	if ((*ppzv)->type!=IS_ARRAY) {							\
+		if (!(*ppzv)->is_ref) {							\
+			SEPARATE_ZVAL(ppzv);							\
+		}													\
+		convert_to_array(*ppzv);							\
+	}

-#define convert_to_writable_boolean_ex(ppzv)	convert_to_writable_ex_master(ppzv, boolean, BOOL)
-#define convert_to_writable_long_ex(ppzv)		convert_to_writable_ex_master(ppzv, long, LONG)
-#define convert_to_writable_double_ex(ppzv)		convert_to_writable_ex_master(ppzv, double, DOUBLE)
-#define convert_to_writable_string_ex(ppzv)		convert_to_writable_ex_master(ppzv, string, STRING)
-#define convert_to_writable_array_ex(ppzv)		convert_to_writable_ex_master(ppzv, array, ARRAY)
-#define convert_to_writable_object_ex(ppzv)		convert_to_writable_ex_master(ppzv, object, OBJECT)
-#define convert_to_writable_null_ex(ppzv)		convert_to_writable_ex_master(ppzv, null, NULL)
+#define convert_to_object_ex(ppzv)							\
+	if ((*ppzv)->type!=IS_OBJECT) {							\
+		if (!(*ppzv)->is_ref) {							\
+			SEPARATE_ZVAL(ppzv);							\
+		}													\
+		convert_to_object(*ppzv);							\
+	}

+#define convert_to_boolean_ex(ppzv)							\
+	if ((*ppzv)->type!=IS_BOOL) {							\
+		if (!(*ppzv)->is_ref) {							\
+			SEPARATE_ZVAL(ppzv);							\
+		}													\
+		convert_to_boolean(*ppzv);							\
+	}

 #define convert_scalar_to_number_ex(ppzv)							\
 	if ((*ppzv)->type!=IS_LONG && (*ppzv)->type!=IS_DOUBLE) {		\
@@ -201,40 +128,4 @@ ZEND_API int zend_atoi(const char *str, int str_len);
 		convert_scalar_to_number(*ppzv);							\
 	}

-
-
-#define Z_LVAL(zval)		(zval).value.lval
-#define Z_BVAL(zval)		((zend_bool)(zval).value.lval)
-#define Z_DVAL(zval)		(zval).value.dval
-#define Z_STRVAL(zval)		(zval).value.str.val
-#define Z_STRLEN(zval)		(zval).value.str.len
-#define Z_ARRVAL(zval)		(zval).value.ht
-#define Z_OBJPROP(zval)		(zval).value.obj.properties
-#define Z_OBJCE(zval)		(zval).value.obj.ce
-#define Z_RESVAL(zval)		(zval).value.lval
-
-#define Z_LVAL_P(zval_p)		Z_LVAL(*zval_p)
-#define Z_BVAL_P(zval_p)		Z_BVAL(*zval_p)
-#define Z_DVAL_P(zval_p)		Z_DVAL(*zval_p)
-#define Z_STRVAL_P(zval_p)		Z_STRVAL(*zval_p)
-#define Z_STRLEN_P(zval_p)		Z_STRLEN(*zval_p)
-#define Z_ARRVAL_P(zval_p)		Z_ARRVAL(*zval_p)
-#define Z_OBJPROP_P(zval_p)		Z_OBJPROP(*zval_p)
-#define Z_OBJCE_P(zval_p)		Z_OBJCE(*zval_p)
-#define Z_RESVAL_P(zval_p)		Z_RESVAL(*zval_p)
-
-#define Z_LVAL_PP(zval_pp)		Z_LVAL(**zval_pp)
-#define Z_BVAL_PP(zval_pp)		Z_BVAL(**zval_pp)
-#define Z_DVAL_PP(zval_pp)		Z_DVAL(**zval_pp)
-#define Z_STRVAL_PP(zval_pp)	Z_STRVAL(**zval_pp)
-#define Z_STRLEN_PP(zval_pp)	Z_STRLEN(**zval_pp)
-#define Z_ARRVAL_PP(zval_pp)	Z_ARRVAL(**zval_pp)
-#define Z_OBJPROP_PP(zval_pp)	Z_OBJPROP(**zval_pp)
-#define Z_OBJCE_PP(zval_pp)		Z_OBJCE(**zval_pp)
-#define Z_RESVAL_PP(zval_pp)	Z_RESVAL(**zval_pp)
-
-#define Z_TYPE(zval)		(zval).type
-#define Z_TYPE_P(zval_p)	Z_TYPE(*zval_p)
-#define Z_TYPE_PP(zval_pp)	Z_TYPE(**zval_pp)
-
 #endif
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -42,7 +42,7 @@ ZEND_API inline void zend_ptr_stack_push(zend_ptr_stack *stack, void *ptr)
 	*(stack->top_element++) = ptr;
 }

-ZEND_API void zend_ptr_stack_n_push(zend_ptr_stack *stack, int count, ...)
+ZEND_API inline void zend_ptr_stack_n_push(zend_ptr_stack *stack, int count,...)
 {
 	va_list ptr;
 	void *elem;
@@ -64,7 +64,7 @@ ZEND_API void zend_ptr_stack_n_push(zend_ptr_stack *stack, int count, ...)
 }


-ZEND_API void zend_ptr_stack_n_pop(zend_ptr_stack *stack, int count, ...)
+ZEND_API inline void zend_ptr_stack_n_pop(zend_ptr_stack *stack, int count,...)
 {
 	va_list ptr;
 	void **elem;
@@ -104,22 +104,11 @@ ZEND_API void zend_ptr_stack_apply(zend_ptr_stack *stack, void (*func)(void *))
 }


-ZEND_API void zend_ptr_stack_clean(zend_ptr_stack *stack, void (*func)(void *), zend_bool free_elements)
+ZEND_API void zend_ptr_stack_clean(zend_ptr_stack *stack, void (*func)(void *))
 {
 	zend_ptr_stack_apply(stack, func);
-	if (free_elements) {
-		int i = stack->top;
-
-		while (--i >= 0) {
-			efree(stack->elements[i]);
-		}
-	}
 	stack->top = 0;
 	stack->top_element = stack->elements;
 }


-ZEND_API int zend_ptr_stack_num_elements(zend_ptr_stack *stack)
-{
-	return stack->top;
-}
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -18,11 +18,11 @@
 */


-#ifndef ZEND_PTR_STACK_H
-#define ZEND_PTR_STACK_H
+#ifndef _ZEND_PTR_STACK_H
+#define _ZEND_PTR_STACK_H

 typedef struct _zend_ptr_stack {
-	int top, max;
+	short top, max;
 	void **elements;
 	void **top_element;
 } zend_ptr_stack;
@@ -32,12 +32,11 @@ typedef struct _zend_ptr_stack {

 ZEND_API void zend_ptr_stack_init(zend_ptr_stack *stack);
 ZEND_API void zend_ptr_stack_push(zend_ptr_stack *stack, void *ptr);
-ZEND_API void zend_ptr_stack_n_push(zend_ptr_stack *stack, int count, ...);
+ZEND_API void zend_ptr_stack_n_push(zend_ptr_stack *stack, int count,...);
 ZEND_API void *zend_ptr_stack_pop(zend_ptr_stack *stack);
-ZEND_API void zend_ptr_stack_n_pop(zend_ptr_stack *stack, int count, ...);
+ZEND_API void zend_ptr_stack_n_pop(zend_ptr_stack *stack, int count,...);
 ZEND_API void zend_ptr_stack_destroy(zend_ptr_stack *stack);
 ZEND_API void zend_ptr_stack_apply(zend_ptr_stack *stack, void (*func)(void *));
-ZEND_API void zend_ptr_stack_clean(zend_ptr_stack *stack, void (*func)(void *), zend_bool free_elements);
-ZEND_API int zend_ptr_stack_num_elements(zend_ptr_stack *stack);
+ZEND_API void zend_ptr_stack_clean(zend_ptr_stack *stack, void (*func)(void *));

-#endif /* ZEND_PTR_STACK_H */
+#endif /* _ZEND_PTR_STACK_H */
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -26,7 +26,7 @@
 # include <stdarg.h>
 #endif

-#if ZEND_BROKEN_SPRINTF
+#if BROKEN_SPRINTF
 int zend_sprintf(char *buffer, const char *format, ...)
 {
 	va_list args;
@@ -2,12 +2,12 @@
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998, 1999 Andi Gutmans, Zeev Suraski                  |
   +----------------------------------------------------------------------+
-   | This source file is subject to version 0.92 of the Zend license,     |
+   | This source file is subject to version 0.91 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.                                |
+   | http://www.zend.com/license/0_91.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.              |
@@ -118,7 +118,7 @@ ZEND_API int zend_stack_count(zend_stack *stack)
 }


-ZEND_API void zend_stack_apply(zend_stack *stack, int type, int (*apply_function)(void *element))
+ZEND_API void zend_stack_apply(zend_stack *stack, int (*apply_function)(void *element), int type)
 {
 	int i;

@@ -141,7 +141,7 @@ ZEND_API void zend_stack_apply(zend_stack *stack, int type, int (*apply_function
 }


-ZEND_API void zend_stack_apply_with_argument(zend_stack *stack, int type, int (*apply_function)(void *element, void *arg), void *arg)
+ZEND_API void zend_stack_apply_with_argument(zend_stack *stack, int (*apply_function)(void *element, void *arg), int type, void *arg)
 {
 	int i;