pike.git / lib / modules / Standards.pmod / URI.pike

version» Context lines:

pike.git/lib/modules/Standards.pmod/URI.pike:1:   //! This class implements URI parsing and resolving of relative references to   //! absolute form, as defined in RFC 2396      // Implemented by Johan Sundström and Johan Schön.   // Copyright (c) Roxen Internet Software 2001 - // $Id: URI.pike,v 1.2 2001/01/11 22:17:42 js Exp $ + // $Id: URI.pike,v 1.3 2001/01/12 23:52:23 grubba Exp $    -  + #pragma strict_types +    //! Scheme component of URI   string scheme;      //! Authority component of URI (formerly called net_loc, from RFC 2396 known as authority)   string authority;      //! Path component of URI. May be empty, but not undefined.   string path;      //! Query component of URI. May be 0 if not present.
pike.git/lib/modules/Standards.pmod/URI.pike:21:   string fragment;      //! Certain classes of URI (e.g. URL) may have these defined   string host, user, password;      //! If no port number is present in URI, but the scheme used has a default port number,   //! this number is put here.   int port;      //! The base URI object, if present - object|int(0..0) base_uri; + object(this_program) base_uri;      string raw_uri;      #define error(S) throw( ({ (S), backtrace() }) )   #ifdef STANDARDS_URI_DEBUG   #define debug(X, Y) werror("Standards.URI: "+X+"\n", Y)   #define debug_n(X, Y) werror("Standards.URI: "+X+"\n", @Y)   #else   #define debug(X, Y)   #define debug_n(X, Y)
pike.git/lib/modules/Standards.pmod/URI.pike:44:   // Parse authority component (according to RFC 1738, § 3.1)   static void parse_authority()   {    if(sscanf(authority, "%[^@]@%s", string auth, authority) == 2)    {    sscanf(auth, "%[^:]:%s", user, password); // auth info present    debug_n("parse_authority(): user=%O, password=%O",    ({ user, password }));    }    if(scheme) -  port = Protocols.Ports.tcp[scheme]; // Set a good default á la RFC 1700 +  port = [int]Protocols.Ports.tcp[scheme]; // Set a good default á la RFC 1700    sscanf(authority, "%[^:]%*[:]%d", host, port);    debug_n("parse_authority(): host=%O, port=%O", ({ host, port }));   }         // Inherit all properties except raw_uri and base_uri from the URI uri. :-) - static void inherit_properties(object uri) + static void inherit_properties(object(this_program) uri)   {    authority = uri->authority;    scheme = uri->scheme;    user = uri->user; password = uri->password;    host = uri->host; query = uri->query;    port = uri->port;    path = uri->path; fragment = uri->fragment;   }      //! Compare this URI to something, in a canonical way.
pike.git/lib/modules/Standards.pmod/URI.pike:152:      //! @decl void reparse_uri()   //! @decl void reparse_uri(URI base_uri)   //! @decl void reparse_uri(string base_uri)   //! Reparse the URI with respect to a new base URI. If   //! no base_uri was supplied, the old base_uri is thrown away.   //! The resolving is performed according to the guidelines   //! outlined by RFC 2396, Uniform Resource Identifiers (URI): Generic Syntax.   //! @param base_uri   //! Set the new base URI to this. - void reparse_uri(object|string|void _base_uri) + void reparse_uri(object(this_program)|string|void base_uri)   {    string uri = raw_uri;    -  if(stringp(_base_uri)) +  if(stringp(base_uri))    { -  debug("cloning base URI %O", _base_uri); -  base_uri = object_program(this_object())(_base_uri); // create a new URI object +  debug("cloning base URI %O", base_uri); +  local::base_uri = object_program(this_object())(base_uri); // create a new URI object    }    else -  base_uri = _base_uri; +  local::base_uri = [object(this_program)]base_uri;       // RFC 2396, §5.2:    // 1) The URI reference is parsed into the potential four components and    // fragment identifier, as described in Section 4.3.          // 2) If the path component is empty and the scheme, authority, and    // query components are undefined, then it is a reference to the    // current document and we are done. Otherwise, the reference URI's    // query and fragment components are defined as found (or not found)    // within the URI reference and not inherited from the base URI.    // (Doing this at once saves us some useless parsing efforts.)    if(!raw_uri || raw_uri == "")    {    debug("Path is empty -- Inherit entire base URI as per RFC 2396, §5.2 step 2. Done!", 0); -  inherit_properties(base_uri); +  inherit_properties(local::base_uri);    return;    }       if(raw_uri[0] == '#')    {    debug("Fragment only. Using entire base URI, except fragment.", 0); -  inherit_properties(base_uri); +  inherit_properties(local::base_uri);    fragment=raw_uri[1..];    return;    }       // Parse fragment identifier    sscanf(uri, "%s#%s", uri, fragment);    debug("Found fragment %O", fragment);       // Parse scheme    if(sscanf(uri, "%[A-Za-z0-9+.-]:%s", scheme, uri) < 2)    {    scheme = 0; -  if(!base_uri) +  if(!local::base_uri)    error("Standards.URI: got a relative URI (no scheme) lacking a base_uri!\n");    }    debug("Found scheme %O", scheme);       // Parse authority/login    if(sscanf(uri, "//%[^/]%s", authority, uri))    {    debug("Found authority %O", authority);    }       // Parse query information    sscanf(uri, "%s?%s", uri, query);    if(query && !sizeof(query)) query = 0;    debug("Found query %O", query);       // Parse path:    path = uri;    debug("Found path %O", path);    -  +  if(authority) +  parse_authority();       // 3) If the scheme component is defined, indicating that the reference    // starts with a scheme name, then the reference is interpreted as an    // absolute URI and we are done. Otherwise, the reference URI's    // scheme is inherited from the base URI's scheme component.    if(scheme)    {    debug("Scheme found! RFC 2396, §5.2, step 3 says we're absolute. Done!", 0);    return;    } -  scheme = base_uri->scheme; +  scheme = local::base_uri->scheme;    debug("Inherited scheme %O from base URI", scheme);    -  if(authority) -  parse_authority(); +     -  +     // 4) If the authority component is defined, then the reference is a    // network-path and we skip to step 7. Otherwise, the reference    // URI's authority is inherited from the base URI's authority    // component, which will also be undefined if the URI scheme does not    // use an authority component.    if(!authority || !sizeof(authority))    { -  authority = base_uri->authority; +  authority = local::base_uri->authority;    debug("Inherited authority %O from base URI", authority);    parse_authority();       // 5) If the path component begins with a slash character ("/"), then    // the reference is an absolute-path and we skip to step 7.    if(!sscanf(path, "/%*s"))    {       // 6) If this step is reached, then we are resolving a relative-path    // reference. The relative path needs to be merged with the base    // URI's path. Although there are many ways to do this, we will    // describe a simple method using a separate string buffer.       debug_n("Combining base path %O with path %O => %O", -  ({ base_uri->path, path, combine_uri_path(base_uri->path, path) })); -  path = combine_uri_path(base_uri->path, path); +  ({ local::base_uri->path, path, +  combine_uri_path(local::base_uri->path, path) })); +  path = combine_uri_path(local::base_uri->path, path);       }    }       // 7) The resulting URI components, including any inherited from the    // base URI, are recombined to give the absolute form of the URI reference.    // (Reassembly is done at cast-to-string/sprintf() time)   }      
pike.git/lib/modules/Standards.pmod/URI.pike:283:   //! @decl void create(string uri, URI base_uri)   //! @decl void create(string uri, string base_uri)   //! @param base_uri   //! When supplied, will root the URI a the given location. This is   //! needed to correctly verify relative URIs, but may be left out otherwise.   //! If left out, and uri is a relative URI, an error is thrown.   //! @param uri   //! When uri is another URI object, the created   //! URI will inherit all properties of the supplied uri   //! except, of course, for its base_uri. - void create(object|string uri, object|string|void _base_uri) + void create(object(this_program)|string uri, +  object(this_program)|string|void base_uri)   { -  debug_n("Create(%O, %O) called!", ({ uri, _base_uri })); +  debug_n("Create(%O, %O) called!", ({ uri, base_uri }));    if(stringp(uri)) -  raw_uri = uri; // Keep for future runs of reparse_uri after a base_uri change +  raw_uri = [string]uri; // Keep for future runs of reparse_uri after a base_uri change    else // if(objectp(uri)) (implied)    {    raw_uri = uri->raw_uri; -  inherit_properties(uri); +  inherit_properties([object(this_program)]uri);    }    -  reparse_uri(_base_uri); +  reparse_uri(base_uri);   }         //! Assign a new value to a property of URI   //! @param property   //! When any of the following properties are used, properties that   //! depend on them are recalculated: user, password, host, port, authority, base_uri.   //! @param value   //! The value to assign to @[property]   mixed `[]=(string property, mixed value)
pike.git/lib/modules/Standards.pmod/URI.pike:322:    case "port":    ::`[]=(property, value);    authority = (user ? user + (password ? ":" + password : "") + "@"    : "") +    (host || "") +    (port != Protocols.Ports.tcp[scheme] ? ":" + port    : "");    return value;       case "authority": -  authority = value; +  authority = [string]value;    parse_authority(); // Set user, password, host and port accordingly    return value;       case "base_uri": -  reparse_uri(value); +  reparse_uri([object(this_program)|string]value);    return base_uri;       default:    return ::`[]=(property, value); // Set and return the new value    }   }      //! Works similar to @[`[]=(string property, mixed value)]   mixed `->=(string property, mixed value) { return `[]=(property, value); }