<?php

/**

 * This script can be used for generating PHP model for PDT.

 * It builds PHP functions according to the loaded extensions in running PHP,

 * using complementary information gathered from PHP.net documentation

 *

 * @author Michael Spector <michael@zend.com>

 */

define("BRANCH_DIR", ""); // can be e.g. "/trunk" (do not forget slash!)

define("DOC_URL", "./html/");      // PHP documentation, separate HTML files

if (!is_dir(DOC_URL)) {

    die('Incorrect directory for separated HTML files ("./html/" expected)!');

}

if (version_compare(phpversion(), "5.0.0") < 0) {

	die ("This script requires PHP 5.0.0 or higher!\n");

}

$splitFiles = true;

$phpdocDir = null;

$phpDir = "php";

// Parse arguments:

$argv = $_SERVER["argv"];

$argv0 = array_shift ($argv);

for ($i = 0; $i < count($argv); ++$i) {

	switch ($argv[$i]) {

		case "-nosplit":

			$splitFiles = false;

			break;

		case "-help":

			show_help();

			break;

		default:

			$phpdocDir = $argv[$i];

	}

}

if (!$phpdocDir) {

	show_help();

}

/***************** REMOVED FUNCTIONS (START) *************************/

// add these functions to $removedFunctions!

if (!function_exists('ob_iconv_handler')) {

    function ob_iconv_handler($contents, $status) {}

}

if (!function_exists('ob_tidyhandler')) {

    function ob_tidyhandler($input, $mode = 0) {}

}

if (!function_exists('session_register')) {

    function session_register($name, $_ = null) {}

}

if (!function_exists('session_unregister')) {

    function session_unregister($name) {}

}

if (!function_exists('session_is_registered')) {

    function session_is_registered($name) {}

}

if (!function_exists('chroot')) {

    function chroot($directory) {}

}

/***************** REMOVED FUNCTIONS (END) *************************/

$entities = parse_entities($phpdocDir);

$extensions = get_loaded_extensions();

$functionsDoc = parse_phpdoc_functions ($phpdocDir, $extensions);

$fieldsDoc = parse_phpdoc_fields ($phpdocDir, $extensions);

$classesDoc = parse_phpdoc_classes ($phpdocDir, $extensions);

$constantsDoc = parse_phpdoc_constants ($phpdocDir);

$removedFunctions = array(

    'ob_iconv_handler',

    'ob_tidyhandler',

    'session_register',

    'session_unregister',

    'session_is_registered',

    'chroot',

);

$functionBlackList = array(

    'oci_lob_save' => 1,

    'oci_lob_import' => 1,

    'oci_lob_size' => 1,

    'oci_lob_load' => 1,

    'oci_lob_read' => 1,

    'oci_lob_eof' => 1,

    'oci_lob_tell' => 1,

    'oci_lob_truncate' => 1,

    'oci_lob_erase' => 1,

    'oci_lob_flush' => 1,

    'ocisetbufferinglob' => 1,

    'ocigetbufferinglob' => 1,

    'oci_lob_rewind' => 1,

    'oci_lob_write' => 1,

    'oci_lob_append' => 1,

    'oci_lob_export' => 1,

    'oci_lob_seek' => 1,

    'oci_free_collection' => 1,

    'oci_collection_append' => 1,

    'oci_collection_element_get' => 1,

    'oci_collection_element_assign' => 1,

    'oci_collection_size' => 1,

    'oci_collection_max' => 1,

    'oci_collection_trim' => 1,

    'oci_collection_assign' => 1,

);

$methodBlackList = array(

    'clone',

    'throw',

    'isset',

    'echo',

    'eval',

);

$preferHtmlProperties = array(

    'mysqli',

);

$processedFunctions = $functionBlackList;

$processedClasses = array();

$processedConstants = array();

@mkdir ($phpDir);

if (!$splitFiles) {

	begin_file_output();

}

foreach ($extensions as $extName) {

	if ($splitFiles) {

		begin_file_output();

	}

	print_extension (new ReflectionExtension ($extName));

	if ($splitFiles) {

		finish_file_output("{$phpDir}/{$extName}.php");

	}

}

if ($splitFiles) {

	begin_file_output();

}

$intFunctions = get_defined_functions();

foreach ($intFunctions["internal"] as $intFunction) {

	if (!@$processedFunctions[strtolower($intFunction)]) {

		print_function (new ReflectionFunction ($intFunction));

	}

}

$intClasses = array_merge (get_declared_classes(), get_declared_interfaces(), get_declared_traits());

foreach ($intClasses as $intClass) {

    if (strpos($intClass, 'NetBeans_') === 0) {

        continue;

    }

	if (!@$processedClasses[strtolower($intClass)]) {

		print_class (new ReflectionClass ($intClass));

	}

}

print "\n";

$constants = get_defined_constants(true);

$intConstants = isset($constants["internal"]) ? $constants["internal"] : array();

// add magic constants:

$intConstants['__FILE__'] = null;

$intConstants['__LINE__'] = null;

$intConstants['__CLASS__'] = null;

$intConstants['__FUNCTION__'] = null;

$intConstants['__METHOD__'] = null;

$intConstants['__TRAIT__'] = null;

if (version_compare(phpversion(), "5.3.0") >= 0) {

	$intConstants['__DIR__'] = null;

	$intConstants['__NAMESPACE__'] = null;

}

foreach ($intConstants as $name => $value) {

	if (!@$processedConstants[$name]) {

		print_constant ($name, $value);

	}

}

finish_file_output("{$phpDir}/basic.php");

// removed functions

if ($splitFiles) {

    begin_file_output();

}

foreach ($removedFunctions as $removedFunction) {

	if (!@$processedFunctions[strtolower($removedFunction)]) {

		print_function (new ReflectionFunction ($removedFunction));

	}

}

if ($splitFiles) {

    finish_file_output("{$phpDir}/removed.php");

}

// Create .list file

$fp = fopen ("{$phpDir}/.list", "w");

foreach (glob("{$phpDir}/*.php") as $f) {

	fwrite ($fp, basename($f));

	fwrite ($fp, "\n");

}

fclose($fp);

function findVerInfo($file)

 {

    $url = DOC_URL.$file.".html";

    $search_for = '<p class="verinfo">';

    //echo "Reading $url :\n";

    if (!is_file($url)) {

        return;

    }

    $file_contents = file_get_contents($url);

    $start_pos = strpos($file_contents, $search_for);

    if ($start_pos !== 0) {

       $start_pos += strlen($search_for);

       $end_pos = strpos($file_contents, '</p>', $start_pos);

       if ($end_pos !== 0) {

          $verinfo = substr($file_contents, $start_pos, $end_pos - $start_pos);

          //echo "Ver. info: $verinfo\n";

          return $verinfo;

       }

    }

 }

// === Functions ===

/**

 * Makes generic key from given function name

 * @param name string Function name

 * @return string generic key

 */

function make_funckey_from_str ($name) {

	$name = str_replace ("->", "::", $name);

	$name = str_replace ("()", "", $name);

	$name = strtolower ($name);

	return $name;

}

/**

 * Replaces all invalid charaters with '_' in PHP identifier

 * @param name PHP identifier

 * @return string PHP identifier with stripped invalid characters

 */

function clean_php_identifier ($name) {

	$name = preg_replace('/[^\$\w\_]+/', '_', $name);

	return $name;

}

function clean_php_value($type) {

    $type = trim($type);

    $type = str_replace("&null;", "null", $type);

    $type = str_replace("&true;", "true", $type);

    $type = str_replace("&false;", "false", $type);

    $type = str_replace(""", "", $type);

    $type = strip_tags($type);

    return $type;

}

/**

 * Makes generic key from given function reference

 * @param name ReflectionMethod function reference

 * @return string generic key

 */

function make_funckey_from_ref ($ref) {

	if ($ref instanceof ReflectionMethod) {

		$funckey = make_classmember_ref($ref->getDeclaringClass()->getName(), $ref->getName());

	} else {

		$funckey = strtolower($ref->getName());

	}

	return $funckey;

}

function make_property_from_ref ($ref) {

	if ($ref instanceof ReflectionProperty) {

		$funckey = make_classmember_ref($ref->getDeclaringClass()->getName(), $ref->getName());

	} else {

		throw new Exception("Unexpected type: ".gettype($ref));

	}

	return $funckey;

}

function make_classmember_ref ($className, $memberName) {

	return strtolower($className)."::".strtolower($memberName);

}

/**

 * Parses PHP documentation

 * @param phpdocDir string PHP.net documentation directory

 * @return array Function information gathered from the PHP.net documentation by parsing XML files

 */

function parse_phpdoc_functions ($phpdocDir, $extensions) {

	$xml_files = array_merge (

		glob ("{$phpdocDir}/en" . BRANCH_DIR . "/reference/*/functions/*.xml"),

		glob ("{$phpdocDir}/en" . BRANCH_DIR . "/language/predefined/*/*.xml"),

		glob ("{$phpdocDir}/en" . BRANCH_DIR . "/reference/*/functions/*/*.xml")

	);

	foreach ($extensions as $extName) {

		$extName = strtolower($extName);

		$globPattern = "{$phpdocDir}/en" . BRANCH_DIR . "/reference/{$extName}/*/*.xml";

		$xml_files = array_merge (

			$xml_files,

			glob ($globPattern)

		);

	}

    $functionsDoc = array();

	foreach ($xml_files as $xml_file) {

		$xml = file_get_contents ($xml_file);

		if (preg_match ('@<refentry.*?xml:id=["\'](.*?)["\'].*?>.*?<refname>(.*?)</refname>\s*(?:<refname>(.*?)</refname>)?.*?<refpurpose>(.*?)</refpurpose>@s', $xml, $match)) {

            $id = $match[1];

            $refnames = array($match[2], $match[3]);

            $phpdoc = $match[4];

            foreach ($refnames as $refname) {

                $refname = trim($refname);

                if ($refname == '') {

                    continue;

                }

                $refname = make_funckey_from_str ($refname);

                if (array_key_exists($refname, $functionsDoc)) {

                    // already there

                    continue;

                }

                $functionsDoc[$refname] = array();

                $functionsDoc[$refname]['id'] = $id;

                $functionsDoc[$refname]['quickref'] = xml_to_phpdoc($phpdoc);

                $functionsDoc[$refname]['deprecated'] = strpos($xml_file, "/oldaliases/") !== false;

                if (preg_match ('@<refsect1\s+role=["\']description["\']>(.*?)</refsect1>@s', $xml, $match)) {

                    $description = $match[1];

                    $function_alias = null;

                    $parameters = null;

                    $has_object_style = false;

                    if (preg_match ('@^(.*?)<classsynopsis>.*?<classname>(.*)</classname>.*?<methodsynopsis>.*?<type>(.*?)</type>.*?<methodname>(.*?)</methodname>(.*?)</methodsynopsis>.*?</classsynopsis>(.*)$@s', $description, $match)) {

                        $functionsDoc[$refname]['classname'] = trim($match[2]);

                        $functionsDoc[$refname]['returntype'] = trim($match[3]);

                        $functionsDoc[$refname]['methodname'] = trim($match[4]);

                        $parameters = $match[5];

                        $description = $match[1].$match[6];

                        $has_object_style = true;

                    }

                    $methodsynopsis = null;

                    if ($refname == 'number_format') {

                        $methodsynopsis = preg_match_all ('@<methodsynopsis>.*?<type>(.*?)</type>.*?<methodname>(.*?)</methodname>(.*?)</methodsynopsis>@s', $description, $tmp);

                        $match = array();

                        foreach ($tmp as $key => $val) {

                            $match[$key] = $val[count($val) - 1];

                        }

                    } else {

                        if (strpos($refname, '::') !== false) {

                            $methodsynopsis = preg_match ('@<methodsynopsis role="oop">.*?(?:<type>(.*?)</type>.*?)?<methodname>(.*?)</methodname>(.*?)</methodsynopsis>@s', $description, $match);

                        }

                        if (!$methodsynopsis) {

                            $methodsynopsis = preg_match ('@<methodsynopsis>.*?(?:<type>(.*?)</type>.*?)?<methodname>(.*?)</methodname>(.*?)</methodsynopsis>@s', $description, $match);

                        }

                        if (!$methodsynopsis) {

                            $methodsynopsis = preg_match ('@<constructorsynopsis>.*?(?:<type>(.*?)</type>.*?)?<methodname>(.*?)</methodname>(.*?)</constructorsynopsis>@s', $description, $match);

                        }

                    }

                    if ($methodsynopsis) {

                        if ($has_object_style && make_funckey_from_str($match[2]) != $refname) {

                            $function_alias = trim($match[2]);

                        } else {

                            $functionsDoc[$refname]['returntype'] = trim(str_replace('-', '_', $match[1])); // e.g. OCI-Collection -> OCI_Collection

                            $functionsDoc[$refname]['methodname'] = trim($match[2]);

                                                    $parameters = $match[3];

                        }

                    }

                    if ($parameters) {

                        if (preg_match_all ('@<methodparam\s*(.*?)>.*?<type>(.*?)</type>.*?<parameter\s*(.*?)>(.*?)</parameter>(?:<initializer>(.+?)</initializer>)?.*?</methodparam>@s', $parameters, $match)) {

                            for ($i = 0; $i < count($match[0]); ++$i) {

                                $parameter = array (

                                    'type' => trim(str_replace('-', '_', $match[2][$i])), // e.g. OCI-Collection -> OCI_Collection

                                    'name' => clean_php_identifier(trim($match[4][$i])),

                                );

                                if (preg_match ('@choice=[\'"]opt[\'"]@', $match[1][$i])) {

                                    $parameter['isoptional'] = true;

                                }

                                if (preg_match ('@role=[\'"]reference[\'"]@', $match[3][$i])) {

                                    $parameter['isreference'] = true;

                                }

                                if (@strlen(trim($match[5][$i]))) {

                                    $def = $match[5][$i];

                                    if ($def == '"\"') {

                                        $def = '"\\\\"';

                                    }

                                    $parameter['defaultvalue'] = clean_php_value($def);

                                                                    $parameter['isoptional'] = true;

                                }

                                $functionsDoc[$refname]['parameters'][] = $parameter;

                            }

                        }

                    }

                }

                if (preg_match ('@<refsect1\s+role=["\']parameters["\']>(.*?)</refsect1>@s', $xml, $match)) {

                    $parameters = $match[1];

                    if (preg_match_all('@<varlistentry\s*.*?>.*?<parameter>(.*?)</parameter>.*?<listitem\s*.*?>(.*?)</listitem>.*?</varlistentry>@s', $parameters, $match)) {

                        for ($i = 0; $i < count($match[0]); $i++) {

                            for ($j = 0; $j < count(@$functionsDoc[$refname]['parameters']); $j++) {

                                if (clean_php_identifier(trim($match[1][$i])) == $functionsDoc[$refname]['parameters'][$j]['name']) {

                                    $functionsDoc[$refname]['parameters'][$j]['paramdoc'] = xml_to_phpdoc ($match[2][$i]);

                                    break;

                                }

                            }

                        }

                    }

                }

                if (preg_match ('@<refsect1\s+role=["\']returnvalues["\']>(.*?)</refsect1>@s', $xml, $match)) {

                    $returnvalues = $match[1];

                    if (preg_match ('@<para>\s*(.*)</para>?@s', $returnvalues, $match)) {

                        $functionsDoc[$refname]['returndoc'] = preg_replace("@^Returns @", "", xml_to_phpdoc ($match[1]));

                    }

                }

                // Create information for function alias

                if ($function_alias) {

                    $functionsDoc[$function_alias] = $functionsDoc[$refname];

                }

            }

		}

	}

	return $functionsDoc;

}

/**

 * Parses PHP documentation

 * @param phpdocDir string PHP.net documentation directory

 * @return array Function information gathered from the PHP.net documentation by parsing XML files

 */

function parse_phpdoc_fields ($phpdocDir, $extensions) {

	$xml_files = array();

	foreach ($extensions as $extName) {

		$extName = strtolower($extName);

		$xml_files = array_merge (

			$xml_files,

			glob ("{$phpdocDir}/en" . BRANCH_DIR . "/reference/{$extName}/*.xml"),

                        glob ("{$phpdocDir}/en" . BRANCH_DIR . "/reference/{$extName}/*/*.xml")

		);

	}

        foreach ($xml_files as $xml_file) {

            $xml = file_get_contents($xml_file);

            if (preg_match('@<classsynopsisinfo>.*?<classname>(.*)</classname>.*?</classsynopsisinfo>@s', $xml, $matchOffset, PREG_OFFSET_CAPTURE)) {

                $classname = $matchOffset[1][0];

                if (preg_match_all("@<fieldsynopsis>.*?<type>(.*?)</type>.*?<varname.*?>(.*?)</varname>@s", $xml, $matchOffset,null,$matchOffset[1][1])) {

                    for ($index = 0; $index < count($matchOffset[2]); $index++) {

                        $name = $matchOffset[2][$index];

                        $type= $matchOffset[1][$index];

                        $exploded = explode("::", $name);

                        if (count($exploded) > 1) {

                            $name = $exploded[1];

                        }

                        $reference = make_classmember_ref($classname, $name);

                        $fieldsDoc[$reference]['field'] = $name;

                        $fieldsDoc[$reference]['type'] = $type;

                    }

                }

            } else {

                if (preg_match('@<classsynopsis>.*?<classname>(.*)</classname>.*?<fieldsynopsis>.*?<type>(.*?)</type>.*?<varname.*?>(.*?)</varname>.*?</classsynopsis>@s', $xml, $match)) {

                    $reference = make_classmember_ref($match[1], $match[3]);

                    $fieldsDoc[$reference]['field'] = $match[3];

                    $fieldsDoc[$reference]['type'] = $match[2];

                    //$fieldsDoc[$refname]['quickref'] = trim($match[3]);

                }

            }

        }

        if (isset($fieldsDoc)) {

            return $fieldsDoc;

        }

        return array();

}

/**

 * Parses PHP documentation

 * @param phpdocDir string PHP.net documentation directory

 * @return array Class information gathered from the PHP.net documentation by parsing XML files

 */

function parse_phpdoc_classes ($phpdocDir, $extensions) {

	$xml_files = array_merge (

		glob ("{$phpdocDir}/en" . BRANCH_DIR . "/reference/*/reference.xml"),

		glob ("{$phpdocDir}/en" . BRANCH_DIR . "/reference/*/classes.xml"),

		glob ("{$phpdocDir}/en" . BRANCH_DIR . "/language/*/*.xml"),

		glob ("{$phpdocDir}/en" . BRANCH_DIR . "/language/*.xml")

	);

	foreach ($extensions as $extName) {

		$extName = strtolower($extName);

		$globPattern = "{$phpdocDir}/en" . BRANCH_DIR . "/reference/{$extName}/*.xml";

		$xml_files = array_merge (

			$xml_files,

			glob ($globPattern)

		);

	}

    $classesDoc = array();

	foreach ($xml_files as $xml_file) {

		$xml = file_get_contents ($xml_file);

		if (preg_match ('@xml:id=["\'](.*?)["\']@', $xml, $match)) {

			$id = $match[1];

			$prefixId = substr($id, 0, strlen("class."));

			$clsNamePattern = ($prefixId === "class.") ?

			'@<ooclass><classname>(.*?)</classname></ooclass>@' :

			'@<title><classname>(.*?)</classname></title>@';

			if (preg_match_all ($clsNamePattern, $xml, $match)) {

				for ($i = 0; $i < count($match[0]); ++$i) {

					$class = $match[1][$i];

					$refname = strtolower ($class);

					$classesDoc[$refname]['id'] = $id;

					$classesDoc[$refname]['name'] = $class;

					$offsetPattern = ($prefixId === "class.") ?

						"@xml:id=[\"'](.*?)\.intro[\"']@i" :

						"@<title><classname>{$class}</classname></title>@";

					if (preg_match ($offsetPattern , $xml, $matchOffset,PREG_OFFSET_CAPTURE)) {

						$docPattern = '@<para>(.*?)</para>@s';

						if (preg_match ($docPattern, $xml, $match2,null,$matchOffset[0][1])) {

							$doc = xml_to_phpdoc($match2[1]);

							$classesDoc[$refname]['doc'] = $doc;

						}

					}

				}

			}

		}

	}

	return $classesDoc;

}

/**

 * Parses PHP documentation

 * @param phpdocDir string PHP.net documentation directory

 * @return array Constant information gathered from the PHP.net documentation by parsing XML files

 */

function parse_phpdoc_constants ($phpdocDir) {

	exec ("find ".addslashes($phpdocDir)." -name \"*constants.xml\"", $xml_files);

	foreach ($xml_files as $xml_file) {

		$xml = file_get_contents ($xml_file);

		if (preg_match ('@xml:id=["\'](.*?)["\']@', $xml, $match)) {

			$id = $match[1];

			if (preg_match_all ('@<term>\s*<constant>([a-zA-Z_:][a-zA-Z0-9_:]*)</constant>.*?</term>.*?<listitem>(.*?)</listitem>@s', $xml, $match)) {

				for ($i = 0; $i < count($match[0]); ++$i) {

					$constant = $match[1][$i];

					$constantsDoc[$constant]['id'] = $id;

					$constantsDoc[$constant]['doc'] = xml_to_phpdoc($match[2][$i]);

				}

			}

			if (preg_match_all (

				'@<entry>\s*<constant>([a-zA-Z_][a-zA-Z0-9_]*)</constant>.*?</entry>\s*<entry>\d+</entry>\s*<entry>(.*?)</entry>@s', $xml, $match)

				|| preg_match_all ('@<entry>\s*<constant>([a-zA-Z_][a-zA-Z0-9_]*)</constant>.*?</entry>\s*<entry>(.*?)</entry>@s', $xml, $match)) {

				for ($i = 0; $i < count($match[0]); ++$i) {

					$constant = $match[1][$i];

					$constantsDoc[$constant]['id'] = $id;

					$constantsDoc[$constant]['doc'] = xml_to_phpdoc($match[2][$i]);

				}

			}

		}

	}

	return $constantsDoc;

}

/**

 * Prints ReflectionExtension in format of PHP code

 * @param extRef ReflectionExtension object

 */

function print_extension ($extRef) {

    global $functionBlackList;

	print "\n// Start of {$extRef->getName()} v.{$extRef->getVersion()}\n";

	// process classes:

	$classesRef = $extRef->getClasses();

	if (count ($classesRef) > 0) {

		foreach ($classesRef as $classRef) {

			print_class ($classRef);

		}

	}

	// process functions

	$funcsRef = $extRef->getFunctions();

	if (count ($funcsRef) > 0) {

		foreach ($funcsRef as $funcName => $funcRef) {

                    if (array_key_exists($funcName, $functionBlackList)) {

                        continue;

                    }

			print_function ($funcRef);

		}

		print "\n";

	}

	// process constants

	$constsRef = $extRef->getConstants();

	if (count ($constsRef) > 0) {

		print_constants ($constsRef);

		print "\n";

	}

	print "// End of {$extRef->getName()} v.{$extRef->getVersion()}\n";

}

/**

 * Prints ReflectionClass in format of PHP code

 * @param classRef ReflectionClass object

 * @param tabs integer[optional] number of tabs for indentation

 */

function print_class (ReflectionClass $classRef, $tabs = 0) {

	global $processedClasses, $preferHtmlProperties, $methodBlackList;

	$processedClasses [strtolower($classRef->getName())] = true;

	print "\n";

	print_doccomment ($classRef, $tabs);

	print_tabs ($tabs);

	if ($classRef->isFinal()) print "final ";

        if ($classRef->isInterface()) {

            print "interface ";

        } elseif ($classRef->isTrait()) {

            print "trait ";

        } else {

            print "class ";

        }

	print clean_php_identifier($classRef->getName())." ";

	// print out parent class

	$parentClassRef = $classRef->getParentClass();

	if ($parentClassRef) {

		print "extends {$parentClassRef->getName()} ";

	}

	// print out interfaces

	$interfacesRef = $classRef->getInterfaces();

	if (count ($interfacesRef) > 0) {

		print $classRef->isInterface() ? "extends " : "implements ";

		$i = 0;

		foreach ($interfacesRef as $interfaceRef) {

			if ($i++ > 0) {

				print ", ";

			}

			print "{$interfaceRef->getName()}";

		}

	}

	print " {\n";

	// print out traits

        $traits = $classRef->getTraits();

        if (count($traits)) {

            foreach ($traits as $trait => $traitInfo) {

                print_tabs($tabs + 1);

                print 'use ' . $trait . ';';

		print "\n";

            }

            print "\n";

        }

	// process constants

	$constsRef = $classRef->getConstants();

	if (count ($constsRef) > 0) {

		print_class_constants ($classRef, $constsRef, $tabs + 1);

		print "\n";

	}

	// process properties

	$propertiesRef = $classRef->getProperties();

	if (!in_array(strtolower($classRef->getName()), $preferHtmlProperties)

                && count ($propertiesRef) > 0) {

		foreach ($propertiesRef as $propertyRef) {

			print_property ($propertyRef, $tabs + 1);

		}

		print "\n";

	} else {

        // #188245 - try to find them directly in HTML

        $properties = parse_properties_from_html_file('class.' . strtolower($classRef->getName()) . '.html', $classRef->getName());

        if (count($properties)) {

            foreach ($properties as $property) {

                print_field($property, $tabs + 1);

            }

            print "\n";

        }

    }

	// process methods

	/* @var $classRef ReflectionClass */

	$methodsRef = $classRef->getMethods();

	if (count ($methodsRef) > 0) {

		foreach ($methodsRef as $methodRef) {

            /* @var $methodRef ReflectionMethod */

            if (in_array(strtolower($methodRef->getName()), $methodBlackList)) {

                continue;

            }

			print_method($classRef, $methodRef, $tabs + 1);

		}

		print "\n";

	}

	print_tabs ($tabs);

	print "}\n";

}

/**

 * Prints ReflectionProperty in format of PHP code

 * @param ReflectionProperty $propertyRef  object

 * @param integer[optional] tabs  number of tabs for indentation

 */

function print_property ($propertyRef, $tabs = 0) {

	print_doccomment ($propertyRef, $tabs);

	print_tabs ($tabs);

	print_modifiers ($propertyRef, true);

        $name = $propertyRef->getName();

        if (substr($name, 0, 1) !== '$') {

            $name = '$' . $name;

        }

        print $name . ";\n";

}

/**

 * Prints Field in format of PHP code

 * @param NetBeans_Field $field  object

 * @param integer[optional] tabs  number of tabs for indentation

 */

function print_field (NetBeans_Field $field, $tabs = 0) {

    // documentation

    $fieldType = $field->getType();

    $fieldDoc = $field->getDocumentation();

    $fieldDoc = trim(strip_tags($fieldDoc, '<p>,<strong>,<code>,<a>'));

    // replace hyperlinks

    $fieldDoc = preg_replace('%<(a|strong)[^>]*>%', '<b>', $fieldDoc);

    $fieldDoc = preg_replace('%<p[^>]+>%', '<p>', $fieldDoc);

    $fieldDoc = str_replace('</a>', '</b>', $fieldDoc);

    $fieldDoc = str_replace('</strong>', '</b>', $fieldDoc);

    $fieldDoc = preg_replace('%^<p>(.+)</p>$%s', '<p style="margin-top:0;">\\1</p>', $fieldDoc);

    print_tabs ($tabs);

    print "/**\n";

    foreach (preg_split('%\n|\r%', $fieldDoc) as $line) {

        $line = trim($line);

        if (!$line) {

            continue;

        }

        print_tabs($tabs);

        print " * $line\n";

    }

    print_tabs($tabs);

    print " * @var $fieldType\n";

    print_tabs($tabs);

    print " */\n";

    // tabs

	print_tabs($tabs);

    // modifiers

    $print = implode(' ', $field->getModifiers());

    $print = str_replace("final", "", $print);

    $print = str_replace("abstract", "", $print);

    $print = str_replace("readonly", "", $print);

    $print = trim($print);

    if (!$print) {

        // no modifiers

        $print = 'public';

    }

    print $print;

    print " ";

    $name = $field->getName();

    if (substr($name, 0, 1) !== '$') {

        $name = '$' . $name;

    }

    print $name . ";\n";

}

function print_function ($functionRef, $tabs = 0) {

    print_method(null, $functionRef, $tabs);

}

function print_method ($classRef, $functionRef, $tabs = 0) {

	global $functionsDoc;

	global $processedFunctions;

	$funckey = make_funckey_from_ref ($functionRef);

	$processedFunctions[$funckey] = true;

	print "\n";

        $modifiers = null;

	print_doccomment ($functionRef, $tabs);

	print_tabs ($tabs);

	if (!($functionRef instanceof ReflectionFunction)) {

		print_modifiers ($functionRef);

                $modifiers = Reflection::getModifierNames($functionRef->getModifiers());

	}

	print "function ";

	if ($functionRef->returnsReference()) {

		print "&";

	}

	$functionName = $functionRef->getName();

	print "$functionName(";

	$parameters = @$functionsDoc[$funckey]['parameters'];

	if ($parameters) {

		print_parameters ($parameters);

	} else {

		print_parameters_ref ($functionRef->getParameters());

	}

	print ")";

        $returntype = sanitizeType(@$functionsDoc[$funckey]['returntype']);

        if ($returntype

                && $functionName !== '__construct') {

            print ': ' . $returntype;

        }

        $body = true;

        if ($classRef != null && $classRef->isInterface()) {

            $body = false;

        } elseif (is_array($modifiers)) {

            foreach ($modifiers as $modifier) {

                if ($modifier == "abstract") {

                    $body = false;

                    break;

                }

            }

        }

        if ($body) {

            print " {}";

        } else {

            print ";";

        }

	print "\n";

}

/**

 * Prints ReflectionParameter in format of PHP code

 * @param parameters array information from PHP.net documentation

 */

function print_parameters ($parameters) {

	$i = 0;

	foreach ($parameters as $parameter) {

		if ($parameter['name'] != "...") {

                        $type = sanitizeType($parameter['type']);

                        $nullable = false;

                        $param_value = '';

			if (@$parameter['isoptional']) {

				if (array_key_exists('defaultvalue', $parameter)) {

					$value = $parameter['defaultvalue'];

                                        if ((is_numeric ($value) && $type != 'string')

                                                || in_array(strtolower($value), array('true', 'false', 'null', 'array()'))

                                                || (substr($value, 0, 1) == '\'' && substr($value, -1) == '\'')

                                                || (substr($value, 0, 1) == '"' && substr($value, -1) == '"')

                                                || (substr($value, 0, 2) == '__' && substr($value, -2) == '__')

                                                || isConstant($value)) {

                                            // no apostrophes

                                        } else {

                                            $value = "'{$value}'";

                                        }

                                        $param_value = " = {$value}";

				} else {

                                        $nullable = true;

                                        if (!$type) {

                                            $param_value = " = null";

                                        }

				}

			}

			if ($i++ > 0) {

				print ", ";

			}

			if ($type) {

                                if ($nullable) {

                                    print "?";

                                }

				print "{$type} ";

			}

			if (@$parameter['isreference']) {

				print "&";

			}

                        print "\${$parameter['name']}";

                        if ($param_value) {

                            print $param_value;

                        }

		}

	}

}

/**

 * Prints ReflectionParameter in format of PHP code

 * @param paramsRef ReflectionParameter[] array of objects

 */

function print_parameters_ref ($paramsRef) {

	$i = 0;

	foreach ($paramsRef as $paramRef) {

            /* @var $paramRef ReflectionParameter */

            if ($paramRef->allowsNull()) {

                echo '?';

            }

		if ($paramRef->isArray()) {

			print "array ";

		} else {

			if ($className = get_parameter_classname($paramRef)) {

				print "{$className} ";

			}

		}

		$name = $paramRef->getName() ? $paramRef->getName() : "var".($i+1);

		if ($name != "...") {

			if ($i++ > 0) {

				print ", ";

			}

			if ($paramRef->isPassedByReference()) {

				print "&";

			}

			print "\${$name}";

			if ($paramRef->allowsNull()) {

				print " = null";

			} else if ($paramRef->isDefaultValueAvailable()) {

				$value = $paramRef->getDefaultValue();

				if (!is_numeric ($value)) {

					$value = "'{$value}'";

				}

				print " = {$value}";

			}

		}

	}

}

/**

 * Prints constants in format of PHP code

 * @param constants array containing constants, where key is a name of constant

 * @param tabs integer[optional] number of tabs for indentation

 */

function print_constants ($constants, $tabs = 0) {

	foreach ($constants as $name => $value) {

		print_constant ($name, $value, $tabs);

	}

}

function print_constant ($name, $value = null, $tabs = 0) {

	global $constantsDoc;

	global $processedConstants;

	$processedConstants [$name] = true;

	if ($value === null) {

		$value = @constant ($name);

	}

	$value = escape_const_value ($value);

	$doc = @$constantsDoc[$name]['doc'];

	if ($doc) {

		print "\n";

		print_tabs ($tabs);

		print "/**\n";

		print_tabs ($tabs);

		print " * ".newline_to_phpdoc($doc, $tabs)."\n";

		print_tabs ($tabs);

		print " * @link ".make_url($constantsDoc[$name]['id'])."\n";

		print_tabs ($tabs);

		print " */\n";

	}

	print_tabs ($tabs);

	print "define ('{$name}', {$value});\n";

}

function escape_const_value ($value) {

	if (is_resource($value)) {

		$value = "\"${value}\"";

	} else if (!is_numeric ($value) && !is_bool ($value) && $value !== null) {

		$value = '"'.addcslashes ($value, "\"\r\n\t").'"';

	} else if ($value === null) {

		$value = "null";

	} else if ($value === false) {

		$value = "false";

	} else if ($value === true) {

		$value = "true";

	}

	return $value;

}

/**

 * Prints class constants in format of PHP code

 * @param constants array containing constants, where key is a name of constant

 * @param tabs integer[optional] number of tabs for indentation

 */

function print_class_constants ($classRef, $constants, $tabs = 0) {

    global $constantsDoc;

    global $processedConstants;

    //$doc = @$constantsDoc[$name]['doc'];

    foreach ($constants as $name => $value) {

        $value = escape_const_value ($value);

        $clsName = $classRef->getName();

        $idx = "$clsName::$name";

        $doc = @$constantsDoc[$idx]['doc'];

        if ($doc) {