Visit this project's SourceForge Project Page

EUrl.class.php

Go to the documentation of this file.

<?php if(defined(__FILE__)){return(NULL);}define(__FILE__,TRUE);

define ( "EURL_VAR_PROTOCOL"       , "EURL_VAR_PROTOCOL"       );

define ( "EURL_VAR_USER"           , "EURL_VAR_USER"           );

define ( "EURL_VAR_PASS"           , "EURL_VAR_PASS"           );

define ( "EURL_VAR_DOMAIN"         , "EURL_VAR_DOMAIN"         );

define ( "EURL_VAR_SUB_DOMAIN"     , "EURL_VAR_SUB_DOMAIN"     );

define ( "EURL_VAR_PORT"           , "EURL_VAR_PORT"           );

define ( "EURL_VAR_INDEX_PATH"     , "EURL_VAR_INDEX_PATH"     );

define ( "EURL_VAR_PATH_WITH_KEYS" , "EURL_VAR_PATH_WITH_KEYS" );

define ( "EURL_VAR_PATH_VARS"      , "EURL_VAR_PATH_VARS"      );

define ( "EURL_VAR_FILE_NAME"      , "EURL_VAR_FILE_NAME"      );

define ( "EURL_VAR_GET_VARS"       , "EURL_VAR_GET_VARS"       );

define ( "EURL_VAR_FRAGMENT"       , "EURL_VAR_FRAGMENT"       );

define ( "EURL_SCOPE_INTERNAL"     , "EURL_SCOPE_INTERNAL"     );

define ( "EURL_SCOPE_MINING"       , "EURL_SCOPE_MINING"       );

define ( "EURL_SCOPE_ENVIRONMENT"  , "EURL_SCOPE_ENVIRONMENT"  );

define ( "EURL_SCOPE_CONSTANTS"    , "EURL_SCOPE_CONSTANTS"    );

define ( "EURL_SCOPE_DEFAULTS"     , "EURL_SCOPE_DEFAULTS"     );

define ( "EURL_SCOPE_GLOBAL"       , "EURL_SCOPE_GLOBAL"       );

define ( "EURL_SCOPE_SETTINGS"     , "EURL_SCOPE_SETTINGS"     );

define ( "EURL_SCOPE_PARAMETERS"   , "EURL_SCOPE_PARAMETERS"   );

/*NODEBUG{*/
    define ( "EURL_DEBUG"                  , FALSE               );

    define ( "EURL_DEBUG_KEYNAMES"         , EURL_DEBUG || FALSE );

    define ( "EURL_DEBUG_SCOPEORDER"       , EURL_DEBUG || FALSE );

    define ( "EURL_DEBUG_CONSTANTTOKEY"    , EURL_DEBUG || FALSE );

    define ( "EURL_DEBUG_ENVIRONMENTTOKEY" , EURL_DEBUG || FALSE );

    define ( "EURL_DEBUG_EURL"             , EURL_DEBUG || FALSE );

    define ( "EURL_DEBUG_INTERNAL"         , EURL_DEBUG || FALSE );

    define ( "EURL_DEBUG_MINING"           , EURL_DEBUG || FALSE );

    define ( "EURL_DEBUG_ENVIRONMENT"      , EURL_DEBUG || FALSE );

    define ( "EURL_DEBUG_CONSTANTS"        , EURL_DEBUG || FALSE );

    define ( "EURL_DEBUG_DEFAULTS"         , EURL_DEBUG || FALSE );

    define ( "EURL_DEBUG_GLOBAL"           , EURL_DEBUG || FALSE );

    define ( "EURL_DEBUG_GETVALUES"        , EURL_DEBUG || FALSE );

    define ( "EURL_DEBUG_SETVALUE"         , EURL_DEBUG || FALSE );

    define ( "EURL_DEBUG_GENERATE"         , EURL_DEBUG || FALSE );
/*}NODEBUG*/

class EUrl
{
    var $_Settings;

    function _KeyNames()
    {
        /*NODEBUG{*/
        if(EURL_DEBUG_KEYNAMES)
        {
            print(__CLASS__."::".__FUNCTION__."(");
            foreach(func_get_args() as $arg)
            {
                print(var_export($arg,TRUE).",");
            }
            print(")\n");
        }
        /*}NODEBUG*/

        return(array(
            EURL_VAR_PROTOCOL       ,
            EURL_VAR_USER           ,
            EURL_VAR_PASS           ,
            EURL_VAR_DOMAIN         ,
            EURL_VAR_SUB_DOMAIN     ,
            EURL_VAR_PORT           ,
            EURL_VAR_INDEX_PATH     ,
            EURL_VAR_PATH_WITH_KEYS ,
            EURL_VAR_PATH_VARS      ,
            EURL_VAR_FILE_NAME      ,
            EURL_VAR_GET_VARS       ,
            EURL_VAR_FRAGMENT       ,
            ));
    }

    function _ScopeOrder()
    {
        /*NODEBUG{*/
        if(EURL_DEBUG_SCOPEORDER)
        {
            print(__CLASS__."::".__FUNCTION__."(");
            foreach(func_get_args() as $arg)
            {
                print(var_export($arg,TRUE).",");
            }
            print(")\n");
        }
        /*}NODEBUG*/

        return(array(
            EURL_SCOPE_PARAMETERS   ,
            EURL_SCOPE_SETTINGS     ,
            EURL_SCOPE_GLOBAL       ,
            EURL_SCOPE_DEFAULTS     ,
            EURL_SCOPE_CONSTANTS    ,
            EURL_SCOPE_ENVIRONMENT  ,
            EURL_SCOPE_MINING       ,
            EURL_SCOPE_INTERNAL     ,
            ));
    }

    function _ConstantToKey()
    {
        /*NODEBUG{*/
        if(EURL_DEBUG_CONSTANTTOKEY)
        {
            print(__CLASS__."::".__FUNCTION__."(");
            foreach(func_get_args() as $arg)
            {
                print(var_export($arg,TRUE).",");
            }
            print(")\n");
        }
        /*}NODEBUG*/

        return(array(
            "EURL_VAL_PROTOCOL"       => EURL_VAR_PROTOCOL       ,
            "EURL_VAL_USER"           => EURL_VAR_USER           ,
            "EURL_VAL_PASS"           => EURL_VAR_PASS           ,
            "EURL_VAL_DOMAIN"         => EURL_VAR_DOMAIN         ,
            "EURL_VAL_SUB_DOMAIN"     => EURL_VAR_SUB_DOMAIN     ,
            "EURL_VAL_PORT"           => EURL_VAR_PORT           ,
            "EURL_VAL_INDEX_PATH"     => EURL_VAR_INDEX_PATH     ,
            "EURL_VAL_PATH_WITH_KEYS" => EURL_VAR_PATH_WITH_KEYS ,
            "EURL_VAL_FILE_NAME"      => EURL_VAR_FILE_NAME      ,
            "EURL_VAL_FRAGMENT"       => EURL_VAR_FRAGMENT       ,
            ));
    }

    function _EnvironmentToKey()
    {
        /*NODEBUG{*/
        if(EURL_DEBUG_ENVIRONMENTTOKEY)
        {
            print(__CLASS__."::".__FUNCTION__."(");
            foreach(func_get_args() as $arg)
            {
                print(var_export($arg,TRUE).",");
            }
            print(")\n");
        }
        /*}NODEBUG*/

        return(array(
            "EURL_ENV_PROTOCOL"       => EURL_VAR_PROTOCOL       ,
            "EURL_ENV_USER"           => EURL_VAR_USER           ,
            "EURL_ENV_PASS"           => EURL_VAR_PASS           ,
            "EURL_ENV_DOMAIN"         => EURL_VAR_DOMAIN         ,
            "EURL_ENV_SUB_DOMAIN"     => EURL_VAR_SUB_DOMAIN     ,
            "EURL_ENV_PORT"           => EURL_VAR_PORT           ,
            "EURL_ENV_INDEX_PATH"     => EURL_VAR_INDEX_PATH     ,
            "EURL_ENV_PATH_WITH_KEYS" => EURL_VAR_PATH_WITH_KEYS ,
            "EURL_ENV_FILE_NAME"      => EURL_VAR_FILE_NAME      ,
            "EURL_ENV_FRAGMENT"       => EURL_VAR_FRAGMENT       ,
            ));
    }

    function EUrl()
    {
        /*NODEBUG{*/
        if(EURL_DEBUG_EURL)
        {
            print(__CLASS__."::".__FUNCTION__."(");
            foreach(func_get_args() as $arg)
            {
                print(var_export($arg,TRUE).",");
            }
            print(")\n");
        }
        /*}NODEBUG*/

        $this->_Settings = array();
        foreach(EUrl::_KeyNames() as $key)
        {
            $this->_Settings[$key] = NULL;
        }
    }

    function & _Internal()
    {
        /*NODEBUG{*/
        if(EURL_DEBUG_INTERNAL)
        {
            print(__CLASS__."::".__FUNCTION__."(");
            foreach(func_get_args() as $arg)
            {
                print(var_export($arg,TRUE).",");
            }
            print(")\n");
        }
        /*}NODEBUG*/

        static $defaults = array(
            EURL_VAR_PROTOCOL       => "http"      ,
            EURL_VAR_USER           => NULL        ,
            EURL_VAR_PASS           => NULL        ,
            EURL_VAR_DOMAIN         => "localhost" ,
            EURL_VAR_SUB_DOMAIN     => NULL        ,
            EURL_VAR_PORT           => NULL        ,
            EURL_VAR_INDEX_PATH     => NULL        ,
            EURL_VAR_PATH_WITH_KEYS => FALSE       ,
            EURL_VAR_PATH_VARS      => NULL        ,
            EURL_VAR_FILE_NAME      => NULL        ,
            EURL_VAR_GET_VARS       => NULL        ,
            EURL_VAR_FRAGMENT       => NULL        ,
            );

        return($defaults);
    }

    function & _Mining()
    {
        /*NODEBUG{*/
        if(EURL_DEBUG_MINING)
        {
            print(__CLASS__."::".__FUNCTION__."(");
            foreach(func_get_args() as $arg)
            {
                print(var_export($arg,TRUE).",");
            }
            print(")\n");
        }
        /*}NODEBUG*/

        static $return = NULL;

        if(NULL === $return)
        {
            $return = array(
                EURL_VAR_PROTOCOL       => NULL,
                EURL_VAR_USER           => NULL,
                EURL_VAR_PASS           => NULL,
                EURL_VAR_DOMAIN         => NULL,
                EURL_VAR_SUB_DOMAIN     => NULL,
                EURL_VAR_PORT           => NULL,
                EURL_VAR_INDEX_PATH     => NULL,
                EURL_VAR_PATH_WITH_KEYS => NULL,
                EURL_VAR_PATH_VARS      => NULL,
                EURL_VAR_GET_VARS       => NULL,
                EURL_VAR_FRAGMENT       => NULL,
                );

            if(isset($_SERVER))
            {
                if(isset($_SERVER['HTTPS']))
                {
                    /*NODEBUG{*/
                    if(EURL_DEBUG_MINING)
                    {
                        print(__CLASS__."::".__FUNCTION__."(): ");
                        print("SSL Enabled\n");
                    }
                    /*}NODEBUG*/

                    $return[EURL_VAR_PROTOCOL] = "https";
                }
                if(isset($_SERVER['PHP_AUTH_USER']))
                {
                    /*NODEBUG{*/
                    if(EURL_DEBUG_MINING)
                    {
                        print(__CLASS__."::".__FUNCTION__."(): ");
                        print("User found: ");
                        print($_SERVER['PHP_AUTH_USER']);
                        print("\n");
                    }
                    /*}NODEBUG*/

                    $return[EURL_VAR_USER] = $_SERVER['PHP_AUTH_USER'];
                }
                if(isset($_SERVER['PHP_AUTH_PW']))
                {
                    /*NODEBUG{*/
                    if(EURL_DEBUG_MINING)
                    {
                        print(__CLASS__."::".__FUNCTION__."(): ");
                        print("Password found: ");
                        print($_SERVER['PHP_AUTH_PW']);
                        print("\n");
                    }
                    /*}NODEBUG*/

                    $return[EURL_VAR_PASS] = $_SERVER['PHP_AUTH_PW'];
                }
                if(isset($_SERVER['HTTP_HOST']))
                {
                    $host  = $_SERVER['HTTP_HOST'];
                    $regex = "/^(([^\.]+)\.){0,}([^\.]+\..{2,3})$/";

                    if(preg_match($regex, $host, $match))
                    {
                        $subdomain = $match[2];
                        $domain    = $match[3];

                        if($subdomain)
                        {
                            /*NODEBUG{*/
                            if(EURL_DEBUG_MINING)
                            {
                                print(__CLASS__."::".__FUNCTION__."(): ");
                                print("Subdomain found: ");
                                print($subdomain);
                                print("\n");
                            }
                            /*}NODEBUG*/

                            $return[EURL_VAR_SUB_DOMAIN] = $subdomain;
                        }

                        /*NODEBUG{*/
                        if(EURL_DEBUG_MINING)
                        {
                            print(__CLASS__."::".__FUNCTION__."(): ");
                            print("Domain found: ");
                            print($domain);
                            print("\n");
                        }
                        /*}NODEBUG*/

                        $return[EURL_VAR_DOMAIN] = $domain;
                    }
                }
                if(isset($_SERVER['SCRIPT_NAME']))
                {
                    $path = $_SERVER['SCRIPT_NAME'];
                    $path = trim($path, "\\/");

                    /*NODEBUG{*/
                    if(EURL_DEBUG_MINING)
                    {
                        print(__CLASS__."::".__FUNCTION__."(): ");
                        print("Scriptname found: ");
                        print($path);
                        print("\n");
                    }
                    /*}NODEBUG*/

                    $return[EURL_VAR_INDEX_PATH] = $path;
                }
                if(isset($_SERVER['SERVER_PORT']))
                {
                    /*NODEBUG{*/
                    if(EURL_DEBUG_MINING)
                    {
                        print(__CLASS__."::".__FUNCTION__."(): ");
                        print("Port number found: ");
                        print($_SERVER['SERVER_PORT']);
                        print("\n");
                    }
                    /*}NODEBUG*/

                    $return[EURL_VAR_PORT] = $_SERVER['SERVER_PORT'];
                }
            }
        }

        return($return);
    }

    function & _Environment()
    {
        /*NODEBUG{*/
        if(EURL_DEBUG_ENVIRONMENT)
        {
            print(__CLASS__."::".__FUNCTION__."(");
            foreach(func_get_args() as $arg)
            {
                print(var_export($arg,TRUE).",");
            }
            print(")\n");
        }
        /*}NODEBUG*/

        static $return = NULL;

        if(NULL === $return)
        {
            foreach(EUrl::_EnvironmentToKey() as $env_key => $key)
            {
                if(isset($_ENV[$env_key]))
                {
                    /*NODEBUG{*/
                    if(EURL_DEBUG_ENVIRONMENT)
                    {
                        print(__CLASS__."::".__FUNCTION__."(): ");
                        print("$key found in environment\n");
                    }
                    /*}NODEBUG*/

                    $return[$key] =& $_ENV[$env_key];
                }
                elseif(isset($_SERVER[$env_key]))
                {
                    /*NODEBUG{*/
                    if(EURL_DEBUG_ENVIRONMENT)
                    {
                        print(__CLASS__."::".__FUNCTION__."(): ");
                        print("$key found in server vars\n");
                    }
                    /*}NODEBUG*/

                    $return[$key] =& $_SERVER[$env_key];
                }
                else
                {
                    $return[$key] =  NULL;
                }
            }
        }

        return($return);
    }

    function & _Constants()
    {
        /*NODEBUG{*/
        if(EURL_DEBUG_CONSTANTS)
        {
            print(__CLASS__."::".__FUNCTION__."(");
            foreach(func_get_args() as $arg)
            {
                print(var_export($arg,TRUE).",");
            }
            print(")\n");
        }
        /*}NODEBUG*/

        static $defined = array();

        // For each allowable constant
        foreach(EUrl::_ConstantToKey() as $val_key => $key)
        {
            // If the current value is NULL
            if(!isset($defined[$key]))
            {
                // And we have a new value...
                if(defined($val_key))
                {
                    /*NODEBUG{*/
                    if(EURL_DEBUG_CONSTANTS)
                    {
                        print(__CLASS__."::".__FUNCTION__."(): ");
                        print("$key found in constant\n");
                    }
                    /*}NODEBUG*/

                    $defined[$key] = constant($val_key);
                }
                else
                {
                    $defined[$key] = NULL;
                }
            }
        }

        return($defined);
    }

    function & _Defaults()
    {
        /*NODEBUG{*/
        if(EURL_DEBUG_DEFAULTS)
        {
            print(__CLASS__."::".__FUNCTION__."(");
            foreach(func_get_args() as $arg)
            {
                print(var_export($arg,TRUE).",");
            }
            print(")\n");
        }
        /*}NODEBUG*/

        static $internal = NULL;

        if(NULL === $internal)
        {
            /*NODEBUG{*/
            if(EURL_DEBUG_DEFAULTS)
            {
                print(__CLASS__."::".__FUNCTION__."(): ");
                print("Initializing static defaults\n");
            }
            /*}NODEBUG*/

            $internal = array();
            foreach(EUrl::_KeyNames() as $key)
            {
                $internal[$key] = NULL;
            }
        }

        return($internal);
    }

    function & _Global()
    {
        /*NODEBUG{*/
        if(EURL_DEBUG_GLOBAL)
        {
            print(__CLASS__."::".__FUNCTION__."(");
            foreach(func_get_args() as $arg)
            {
                print(var_export($arg,TRUE).",");
            }
            print(")\n");
        }
        /*}NODEBUG*/

        static $global_refs = NULL;

        if(NULL === $global_refs)
        {
            /*NODEBUG{*/
            if(EURL_DEBUG_GLOBAL)
            {
                print(__CLASS__."::".__FUNCTION__."(): ");
                print("Referencing _GLOBALS\n");
            }
            /*}NODEBUG*/

            foreach(EUrl::_KeyNames() as $key)
            {
                $global_refs[$key] =& $GLOBALS[$key];
            }
        }

        return($global_refs);
    }

    function GetValues($Params=NULL)
    {
        /*NODEBUG{*/
        if(EURL_DEBUG_GETVALUES)
        {
            print(__CLASS__."::".__FUNCTION__."(");
            foreach(func_get_args() as $arg)
            {
                print(var_export($arg,TRUE).",");
            }
            print(")\n");
        }
        /*}NODEBUG*/

        static $empty       = array();
        static $static_vars = NULL;

        // The static bits which don't change, IE: Internal defaults,
        // data mined from PHP, etc.
        if(NULL === $static_vars)
        {
            /*NODEBUG{*/
            if(EURL_DEBUG_GETVALUES)
            {
                print(__CLASS__."::".__FUNCTION__."(): ");
                print("Initializing completely static returns\n");
            }
            /*}NODEBUG*/

            $static_vars = array();
            $static_vars[EURL_SCOPE_INTERNAL   ] =& EUrl::_Internal();
            $static_vars[EURL_SCOPE_CONSTANTS  ] =& EUrl::_Constants();
            $static_vars[EURL_SCOPE_MINING     ] =& EUrl::_Mining();
            $static_vars[EURL_SCOPE_ENVIRONMENT] =& EUrl::_Environment();
            $static_vars[EURL_SCOPE_DEFAULTS   ] =& EUrl::_Defaults();
            $static_vars[EURL_SCOPE_GLOBAL     ] =& EUrl::_Global();
        }

        // Now copy all our static variables and referenced variables in
        $vars = array();

        // We rerun this each time because you may have defined MORE
        // constants since the last time we did this.
        EUrl::_Constants();

        // If we're locally instantiated, we'll have settings to grab
        // as well
        if(isset($this))
        {
            /*NODEBUG{*/
            if(EURL_DEBUG_GETVALUES)
            {
                print(__CLASS__."::".__FUNCTION__."(): ");
                print("Getting instantiated settings, too\n");
            }
            /*}NODEBUG*/

            $vars[EURL_SCOPE_SETTINGS] =& $this->_Settings;
        }

        // If they've passed parameters to the Generate function, we
        // want to include them here...
        if(NULL !== $Params)
        {
            /*NODEBUG{*/
            if(EURL_DEBUG_GETVALUES)
            {
                print(__CLASS__."::".__FUNCTION__."(): ");
                print("Including parameters in parse\n");
            }
            /*}NODEBUG*/

            $vars[EURL_SCOPE_PARAMETERS] =& $Params;
        }

        // For each scope
        $return     = array();
        $scopeorder = EUrl::_ScopeOrder();
        $keynames   = EUrl::_KeyNames();
        foreach($scopeorder as $scope)
        {
            $scoped =& $empty;

            if(isset($static_vars[$scope]))
            {
                $scoped =& $static_vars[$scope];
            }

            if(isset($vars[$scope]))
            {
                $scoped =& $vars[$scope];
            }

            foreach($keynames as $key)
            {
                if(!isset($return[$key]) && isset($scoped[$key]))
                {
                    /*NODEBUG{*/
                    if(EURL_DEBUG_GETVALUES)
                    {
                        print(__CLASS__."::".__FUNCTION__."(): ");
                        print("$key from $scope\n");
                    }
                    /*}NODEBUG*/

                    $return[$key] = $scoped[$key];
                }
            }
        }

        return($return);
    }

    function SetValue( $VarName, $Value )
    {
        /*NODEBUG{*/
        if(EURL_DEBUG_SETVALUE)
        {
            print(__CLASS__."::".__FUNCTION__."(");
            foreach(func_get_args() as $arg)
            {
                print(var_export($arg,TRUE).",");
            }
            print(")\n");
        }
        /*}NODEBUG*/

        // Check key name
        if(!in_array($VarName, EUrl::_KeyNames()))
        {
            /*NODEBUG{*/
            if(EURL_DEBUG_SETVALUE)
            {
                print(__CLASS__."::".__FUNCTION__."(): ");
                print("Unknown variable $VarName\n");
            }
            /*}NODEBUG*/

            trigger_error(
                "Unknown EURL_VAR_*: "
                . var_export($VarName, TRUE)
                , E_USER_ERROR
                );
        }

        // Check scope to put it in
        if(isset($this))
        {
            /*NODEBUG{*/
            if(EURL_DEBUG_SETVALUE)
            {
                print(__CLASS__."::".__FUNCTION__."(): ");
                print("Storing $VarName in instantiated object\n");
            }
            /*}NODEBUG*/

            $array =& $this->_Settings;
        }
        else
        {
            /*NODEBUG{*/
            if(EURL_DEBUG_SETVALUE)
            {
                print(__CLASS__."::".__FUNCTION__."(): ");
                print("Storing $VarName in static defaults\n");
            }
            /*}NODEBUG*/

            $array =& EUrl::_Defaults();
        }

        // Store value
        $array[$VarName] = $Value;

        // Return null
        return(NULL);
    }

    function Generate($Extra=NULL)
    {
        /*NODEBUG{*/
        if(EURL_DEBUG_GENERATE)
        {
            print(__CLASS__."::".__FUNCTION__."(");
            foreach(func_get_args() as $arg)
            {
                print(var_export($arg,TRUE).",");
            }
            print(")\n");
        }
        /*}NODEBUG*/

        // Check input
        $KeyNames = EUrl::_KeyNames();
        if(is_array($Extra))
        {
            foreach($Extra as $Key => $Value)
            {
                // Check key name
                if(!in_array($Key, $KeyNames))
                {
                    /*NODEBUG{*/
                    if(EURL_DEBUG_GENERATE)
                    {
                        print(__CLASS__."::".__FUNCTION__."(): ");
                        print("Unknown variable $Key\n");
                    }
                    /*}NODEBUG*/

                    trigger_error(
                        "Unknown EURL_VAR_*: "
                        . var_export($Key, TRUE)
                        , E_USER_ERROR
                        );
                }
            }
        }
        elseif(NULL !== $Extra)
        {
            /*NODEBUG{*/
            if(EURL_DEBUG_GENERATE)
            {
                print(__CLASS__."::".__FUNCTION__."(): ");
                print("Unexpected parameter: ");
                print(var_export($Extra, TRUE));
                print("\n");
            }
            /*}NODEBUG*/

            // Error on invalid input
            trigger_error(
                "Extra must be NULL or Array: "
                . var_export($Extra, TRUE)
                , E_USER_ERROR
                );
        }

        // Depending on scope...
        if(isset($this))
        {
            /*NODEBUG{*/
            if(EURL_DEBUG_GENERATE)
            {
                print(__CLASS__."::".__FUNCTION__."(): ");
                print("Calling from instantiated object\n");
            }
            /*}NODEBUG*/

            $vars = $this->GetValues($Extra);
        }
        else
        {
            /*NODEBUG{*/
            if(EURL_DEBUG_GENERATE)
            {
                print(__CLASS__."::".__FUNCTION__."(): ");
                print("Calling statically\n");
            }
            /*}NODEBUG*/

            $vars = EUrl::GetValues($Extra);
        }

        // Start with an empty string
        $url = "";

        // Add protocol
        if(!isset($vars[EURL_VAR_PROTOCOL]))
        {
            /*NODEBUG{*/
            if(EURL_DEBUG_GENERATE)
            {
                print(__CLASS__."::".__FUNCTION__."(): ");
                print("Protocol must be defined\n");
            }
            /*}NODEBUG*/

            trigger_error(
                "No protocol set!"
                , E_USER_ERROR
                );
        }
        $url .= $vars[EURL_VAR_PROTOCOL];
        $url .= "://";

        // Add username and password
        if(isset($vars[EURL_VAR_USER]))
        {
            /*NODEBUG{*/
            if(EURL_DEBUG_GENERATE)
            {
                print(__CLASS__."::".__FUNCTION__."(): ");
                print("Including user in URL\n");
            }
            /*}NODEBUG*/

            $url .= rawurlencode($vars[EURL_VAR_USER]);
            if(isset($vars[EURL_VAR_PASS]))
            {
                /*NODEBUG{*/
                if(EURL_DEBUG_GENERATE)
                {
                    print(__CLASS__."::".__FUNCTION__."(): ");
                    print("Including password in URL\n");
                }
                /*}NODEBUG*/

                $url .= ':'.rawurlencode($vars[EURL_VAR_PASS]);
            }
            $url .= '@';
        }

        // Add domain name
        if(isset($vars[EURL_VAR_SUB_DOMAIN]))
        {
            /*NODEBUG{*/
            if(EURL_DEBUG_GENERATE)
            {
                print(__CLASS__."::".__FUNCTION__."(): ");
                print("Including sub-domain\n");
            }
            /*}NODEBUG*/

            $url .= $vars[EURL_VAR_SUB_DOMAIN];
            $url .= ".";
        }
        if(!isset($vars[EURL_VAR_DOMAIN]))
        {
            /*NODEBUG{*/
            if(EURL_DEBUG_GENERATE)
            {
                print(__CLASS__."::".__FUNCTION__."(): ");
                print("Domain must be set\n");
            }
            /*}NODEBUG*/

            trigger_error(
                "No domain set!"
                , E_USER_ERROR
                );
        }
        $url .= $vars[EURL_VAR_DOMAIN];

        // Add port
        if(isset($vars[EURL_VAR_PORT]) && $vars[EURL_VAR_PORT])
        {
            /*NODEBUG{*/
            if(EURL_DEBUG_GENERATE)
            {
                print(__CLASS__."::".__FUNCTION__."(): ");
                print("Adding port number to URL\n");
            }
            /*}NODEBUG*/

            $url .= ":";
            $url .= $vars[EURL_VAR_PORT];
        }
        $url .= "/";

        // Add index file
        if(isset($vars[EURL_VAR_INDEX_PATH]))
        {
            /*NODEBUG{*/
            if(EURL_DEBUG_GENERATE)
            {
                print(__CLASS__."::".__FUNCTION__."(): ");
                print("Adding index file path to URL\n");
            }
            /*}NODEBUG*/

            $url .= $vars[EURL_VAR_INDEX_PATH];
        }

        // Add path variables data
        if(!isset($vars[EURL_VAR_PATH_WITH_KEYS]))
        {
            /*NODEBUG{*/
            if(EURL_DEBUG_GENERATE)
            {
                print(__CLASS__."::".__FUNCTION__."(): ");
                print("No determination for handling PATH vars found\n");
            }
            /*}NODEBUG*/

            trigger_error(
                "EURL_VAR_PATH_WITH_KEYS must be boolean!"
                , E_USER_ERROR
                );
        }
        if(isset($vars[EURL_VAR_PATH_VARS]))
        {
            /*NODEBUG{*/
            if(EURL_DEBUG_GENERATE)
            {
                print(__CLASS__."::".__FUNCTION__."(): ");
                print("Including PATH variables in URL\n");
            }
            /*}NODEBUG*/

            foreach($vars[EURL_VAR_PATH_VARS] as $key=>$value)
            {
                if($vars[EURL_VAR_PATH_WITH_KEYS])
                {
                    $url .= "/";
                    $url .= rawurlencode($key  );
                }

                $url .= "/";
                $url .= rawurlencode($value);
            }
        }

        // Add effective file name
        if(isset($vars[EURL_VAR_FILE_NAME]))
        {
            /*NODEBUG{*/
            if(EURL_DEBUG_GENERATE)
            {
                print(__CLASS__."::".__FUNCTION__."(): ");
                print("Including an effective file in URL\n");
            }
            /*}NODEBUG*/

            $url .= "/";
            $url .= $vars[EURL_VAR_FILE_NAME];
        }

        // Add GET parameters
        if(isset($vars[EURL_VAR_GET_VARS]) && $vars[EURL_VAR_GET_VARS])
        {
            /*NODEBUG{*/
            if(EURL_DEBUG_GENERATE)
            {
                print(__CLASS__."::".__FUNCTION__."(): ");
                print("Including GET variables in URL\n");
            }
            /*}NODEBUG*/

            $gets = array();
            foreach($vars[EURL_VAR_GET_VARS] as $key=>$value)
            {
                $gets[] =     rawurlencode($key  ).
                          '='.rawurlencode($value);
            }
            $url .= "?";
            $url .= join("&",$gets);
        }

        // Add Fragment
        if(isset($vars[EURL_VAR_FRAGMENT]) && $vars[EURL_VAR_FRAGMENT])
        {
            /*NODEBUG{*/
            if(EURL_DEBUG_GENERATE)
            {
                print(__CLASS__."::".__FUNCTION__."(): ");
                print("Including FRAGMENT in URL\n");
            }
            /*}NODEBUG*/

            $url .= "#";
            $url .= $vars[EURL_VAR_FRAGMENT];
        }

        /*NODEBUG{*/
        if(EURL_DEBUG_GENERATE)
        {
            print(__CLASS__."::".__FUNCTION__."(): ");
            print("$url\n");
        }
        /*}NODEBUG*/

        return($url);
    }
}

?>

---