url.cpp File Reference

#include "url.hpp"
#include "analyze.hpp"
#include "sys_utils.hpp"
#include "tbox/tbox.h"
#include <ctype.h>

Include dependency graph for url.cpp:

Go to the source code of this file.

Functions
static url_tree	url_tuple (string label)
static url_tree	url_tuple (string label, string value)
static url_tree	url_tuple (string label, string value, string content)
static url_tree	url_tuple (string label, url_tree t1, url_tree t2)
static bool	is_tuple (url_tree t, string s)
static bool	is_tuple (url_tree t, const char *s)
static bool	is_tuple (url_tree t, string s, int n)
static bool	is_tuple (url_tree t, const char *s, int n)
url	url_none ()
url	url_root (string protocol)
url	url_wildcard ()
url	url_wildcard (string name)
void	skip_ipv6 (string s, int &i)
static bool	heuristic_is_path (string name, int type)
static bool	heuristic_is_default (string name, int type)
static bool	heuristic_is_http (string name)
static bool	heuristic_is_ftp (string name)
static bool	heuristic_is_mingw_default (string name, int type)
static url	url_get_atom (string s, int type)
url	url_get_name (string s, int type, int i)
static url	url_get_path (string s, int type=URL_STANDARD, int i=0)
url	url_path (string s, int type)
static url	url_mingw_default (string name, int type)
static url	url_default (string name, int type=URL_SYSTEM)
url	url_general (string name, int type=URL_SYSTEM)
url	url_system (string name)
url	url_system (string dir, string name)
url	url_standard (string name)
url	url_standard (string dir, string name)
url	url_pwd ()
url	url_ramdisc (string contents)
static bool	is_special_root (url u)
static bool	is_semi_root (url u)
url	head (url u)
url	tail (url u)
string	suffix (url u, bool use_locase)
string	suffix (url u)
string	basename (url u, string suf)
string	basename (url u)
url	glue (url u, string s)
url	unglue (url u, int nr)
url	unblank (url u)
url	relative (url base, url u)
url	delta_sub (url base, url u)
url	delta (url base, url u)
string	get_root (url u)
url	unroot (url u)
url	reroot (url u, string protocol)
static url	expand (url u1, url u2)
url	expand (url u)
static bool	operator<= (url u1, url u2)
static url	sort_sub (url add, url to)
url	sort (url u)
static url	factor_sorted (url u)
static url	factor_sub (url u)
url	factor (url u)
bool	descends (url u, url base)
url	operator* (url u1, url u2)
url	operator* (url u1, const char *name)
url	operator* (url u1, string name)
url	url_concat (url u1, url u2)
url	operator| (url u1, url u2)
url	url_or (url u1, url u2)
bool	is_atomic (url u)
bool	is_root (url u, string s)
bool	is_root_web (url u)
bool	is_wildcard (url u, int n)
bool	is_pseudo_atomic (url u)
bool	is_rooted (url u)
bool	is_rooted (url u, string protocol)
bool	is_rooted_web (url u)
bool	is_name (url u)
bool	is_rooted_name (url u)
bool	is_name_in_path (url u)
bool	is_ramdisc (url u)
string	as_string (url u, int type)
tm_ostream &	operator<< (tm_ostream &out, url u)

Detailed Description

Copyright

GPLv3

Unitests for url.

Author

Darcy

Date

2019-2023

Definition in file url.cpp.

Function Documentation

url_tuple() [1/4]

static url_tree url_tuple ( string label )

static

Definition at line 23 of file url.cpp.

                         {
  return url_tree (URL_TUPLE, url_tree (label));
}

url_tuple() [2/4]

static url_tree url_tuple ( string label, string value )

static

Definition at line 28 of file url.cpp.

                                       {
  return url_tree (URL_TUPLE, url_tree (label), url_tree (value));
}

url_tuple() [3/4]

static url_tree url_tuple ( string label, string value, string content )

static

Definition at line 33 of file url.cpp.

                                                       {
  return url_tree (URL_TUPLE, url_tree (label), url_tree (value),
                   url_tree (content));
}

url_tuple() [4/4]

static url_tree url_tuple ( string label, url_tree t1, url_tree t2 )

static

Definition at line 39 of file url.cpp.

                                                   {
  return url_tree (URL_TUPLE, url_tree (label), t1, t2);
}

is_tuple() [1/4]

static bool is_tuple ( url_tree t, string s )

inlinestatic

Definition at line 44 of file url.cpp.

                                {
  return (t->op == URL_TUPLE) && (N (t) >= 1) && (t[0] == s);
}

is_tuple() [2/4]

static bool is_tuple ( url_tree t, const char * s )

inlinestatic

Definition at line 48 of file url.cpp.

                                     {
  return (t->op == URL_TUPLE) && (N (t) >= 1) && (t[0] == s);
}

is_tuple() [3/4]

static bool is_tuple ( url_tree t, string s, int n )

inlinestatic

Definition at line 52 of file url.cpp.

                                       {
  return (t->op == URL_TUPLE) && (N (t) == (n + 1)) && (t[0] == s);
}

is_tuple() [4/4]

static bool is_tuple ( url_tree t, const char * s, int n )

inlinestatic

Definition at line 56 of file url.cpp.

                                            {
  return (t->op == URL_TUPLE) && (N (t) == (n + 1)) && (t[0] == s);
}

url_none()

url url_none

(

)

Definition at line 91 of file url.cpp.

            {
  return as_url (url_tuple ("none"));
}

url_root()

url url_root

(

string

protocol

)

Definition at line 96 of file url.cpp.

                           {
  return as_url (url_tuple ("root", protocol));
}

url_wildcard() [1/2]

url url_wildcard

(

)

Definition at line 101 of file url.cpp.

                { // any url
  return as_url (url_tuple ("wildcard"));
}

url_wildcard() [2/2]

url url_wildcard

(

string

name

)

Definition at line 106 of file url.cpp.

                           { // string with * wildcards
  return as_url (url_tuple ("wildcard", name));
}

skip_ipv6()

void skip_ipv6	(	string	s,
		int &	i )

Definition at line 114 of file url.cpp.

                             {
  i++;
  while (i < N (s) &&
         (s[i] == ':' || (s[i] >= '0' && s[i] <= '9') ||
          (s[i] >= 'a' && s[i] <= 'f') || (s[i] >= 'A' && s[i] <= 'F')))
    i++;
  if (i < N (s) && s[i] == ']') i++;
}

heuristic_is_path()

static bool heuristic_is_path ( string name, int type )

static

Definition at line 124 of file url.cpp.

                                          {
  char sep= (type == 0) ? URL_SEPARATOR : ':';
  int  i= 0, n= N (name);
  while (i < n)
    if (name[i] == '[') skip_ipv6 (name, i);
    else if (name[i] == sep) return true;
    else i++;
  return false;
}

heuristic_is_default()

static bool heuristic_is_default ( string name, int type )

static

Definition at line 135 of file url.cpp.

                                             {
#ifdef WINPATHS
  // FIXME: we probably should take into account 'type' too
  if (N (name) < 2) return false;
  if ((name[0] == '\\') && (name[1] == '\\')) return true;
  return isalpha (name[0]) && (name[1] == ':') &&
         ((N (name) == 2) || (name[2] == '\\') || (name[2] == '/'));
#else
  char sep= (type == 0) ? URL_CONCATER : '/';
  return (name != "") && (name[0] == sep);
#endif
}

heuristic_is_http()

static bool heuristic_is_http ( string name )

static

Definition at line 149 of file url.cpp.

                                {
  return starts (name, "www.");
  // FIXME: we might want to recognize some other ones like google.com too
}

heuristic_is_ftp()

static bool heuristic_is_ftp ( string name )

static

Definition at line 155 of file url.cpp.

                               {
  return starts (name, "ftp.");
}

heuristic_is_mingw_default()

static bool heuristic_is_mingw_default ( string name, int type )

static

Definition at line 160 of file url.cpp.

                                                   {
#ifdef WINPATHS
  return type != URL_SYSTEM && N (name) >= 2 && name[0] == '/' &&
         is_alpha (name[1]) && (N (name) == 2 || name[2] == '/');
#else
  (void) name;
  (void) type;
  return false;
#endif
}

url_get_atom()

static url url_get_atom ( string s, int type )

static

Definition at line 172 of file url.cpp.

                                  {
  if (type < URL_STANDARD) {
    if (s == "~") return url_system (get_env ("HOME"));
    if (starts (s, "$")) {
      string val= get_env (s (1, N (s)));
      if (val == "") return url_none ();
      return unblank (url_system (val));
    }
  }
  if (contains (s, '*')) return url_wildcard (s);
#ifdef WINPATHS
  if (N (s) == 2 && ends (s, ":"))
    s->resize (1); // remove the ':' after unit letter
#endif
  return as_url (url_tree (s));
}

url_get_name()

url url_get_name	(	string	s,
		int	type,
		int	i )

Definition at line 190 of file url.cpp.

                                         {
  char      sep   = (type == URL_SYSTEM) ? URL_CONCATER : '/';
  int       n     = N (s);
  list<url> u_list= list<url> ();
  while (i < n) {
    int start= i;
    while ((i < n) && (s[i] != sep) && (s[i] != '/')) {
      if (s[i] == '[') skip_ipv6 (s, i);
      else i++;
    }
    if (i > start) {
      url u = url_get_atom (s (start, i), type);
      u_list= list (u, u_list);
    }
    else if (i == start) {
      i++;
      if (i == n) {
        u_list= list (as_url (url_tree ("")), u_list);
      }
    }
  }
 
  if (is_nil (u_list)) return as_url (url_tree (""));
  url ret= u_list->item;
  u_list = u_list->next;
  while (!is_nil (u_list)) {
    url u= u_list->item;
    if (is_here (u) || (u->t == "")) {
      // do nothing
    }
    else if (is_atomic (u)) {
      ret= as_url (url_tuple ("concat", u->t, ret->t));
    }
    else {
      ret= u * ret;
    }
    u_list= u_list->next;
  }
  return ret;
}

url_get_path()

static url url_get_path ( string s, int type = URL_STANDARD, int i = 0 )

static

Definition at line 232 of file url.cpp.

                                                          {
  char sep  = (type == URL_SYSTEM) ? URL_SEPARATOR : ':';
  int  start= i, n= N (s);
  if (i == n) return url_none ();
  while ((i < n) && (s[i] != sep)) {
    if (s[i] == '[') skip_ipv6 (s, i);
    else i++;
  }
  url u= url_general (s (start, i), type);
  if (i == n) return u;
  if (start == i) return url_get_path (s, type, i + 1);
  return u | url_get_path (s, type, i + 1);
}

url_path()

url url_path	(	string	s,
		int	type )

Definition at line 247 of file url.cpp.

                              {
  url u= url_get_path (s, type);
  return u;
}

url_mingw_default()

static url url_mingw_default ( string name, int type )

static

Definition at line 253 of file url.cpp.

                                          {
  string s= name (0, 2) * ":" * name (2, N (name));
  return url_root ("default") * url_get_name (s, type);
}

url_default()

static url url_default ( string name, int type = URL_SYSTEM )

static

Definition at line 259 of file url.cpp.

                                                {
  url u= url_get_name (name, type);
#ifdef WINPATHS
  // FIXME: this hack seems a bit too simple
  if (is_concat (u) && (u[2]->t == "")) u= u[1];
  // cout << name << " -> " << url_root ("default") * u << "\n";
  return url_root ("default") * u;
#else
  if (u->t == "") return url_root ("default");
  return url_root ("default") * u;
#endif
}

url_general()

url url_general	(	string	name,
		int	type = URL_SYSTEM )

Definition at line 273 of file url.cpp.

                                                {
  if (contains (name, "://")) {
    array<string> tokens  = tokenize (name, "://");
    string        protocol= tokens[0];
    string        path    = tokens[1];
    if (N (tokens) == 2 && is_alphanum (protocol) && N (protocol) >= 2) {
      if (protocol == "file") return file_url (path);
      if (protocol == "http") return http_url (path);
      if (protocol == "https") return https_url (path);
      if (protocol == "ftp") return ftp_url (path);
      return url_root (tokens[0]) * url_get_name (tokens[1], type);
    }
  }
  if (starts (name, "local:")) {
    return file_url (name (6, N (name)));
  }
  if (starts (name, "//")) {
    return blank_url (name (2, N (name)));
  }
  if (heuristic_is_path (name, type)) {
    return url_path (name, type);
  }
  if (heuristic_is_default (name, type)) return url_default (name, type);
  if (os_mingw () && heuristic_is_mingw_default (name, type))
    return url_mingw_default (name, type);
  if (type != URL_CLEAN_UNIX) {
    if (heuristic_is_http (name)) return http_url (name);
    if (heuristic_is_ftp (name)) return ftp_url (name);
  }
  return url_get_name (name, type);
}

url_system() [1/2]

url url_system

(

string

name

)

Definition at line 306 of file url.cpp.

                         {
  return url_general (name, URL_SYSTEM);
}

url_system() [2/2]

url url_system	(	string	dir,
		string	name )

Definition at line 311 of file url.cpp.

                                     {
  return url_system (dir) * url_system (name);
}

url_standard() [1/2]

url url_standard

(

string

name

)

Definition at line 316 of file url.cpp.

                           {
  return url_general (name, URL_STANDARD);
}

url_standard() [2/2]

url url_standard	(	string	dir,
		string	name )

Definition at line 321 of file url.cpp.

                                       {
  return url_standard (dir) * url_standard (name);
}

url_pwd()

url url_pwd

(

)

Definition at line 326 of file url.cpp.

           {
  char path[TB_PATH_MAXN];
  if (tb_directory_current (path, TB_PATH_MAXN)) {
    return url_system (path);
  }
  else {
    TM_FAILED ("FAILED to get pwd");
    return url_none ();
  }
}

url_ramdisc()

url url_ramdisc

(

string

contents

)

Definition at line 341 of file url.cpp.

                              {
  return as_url (url_tuple ("root", "ramdisc", contents));
}

is_special_root()

static bool is_special_root ( url u )

static

Definition at line 350 of file url.cpp.

                        {
#ifdef WINPATHS
  return is_root (u);
#else
  return is_root_web (u);
#endif
}

is_semi_root()

static bool is_semi_root ( url u )

static

Definition at line 359 of file url.cpp.

                     {
  // url u such that u/.. == u (website or windows drive name)
  return is_concat (u) && is_special_root (u[1]) && is_atomic (u[2]);
}

head()

url head

(

url

u

)

Definition at line 365 of file url.cpp.

             {
  return u * url_parent ();
}

tail()

url tail

(

url

u

)

Definition at line 370 of file url.cpp.

             {
  if (is_concat (u)) {
    if (is_root_web (u[1]) && is_atomic (u[2])) return url_here ();
    return tail (u[2]);
  }
  if (is_or (u)) return tail (u[1]) | tail (u[2]);
  if (is_root (u)) return url_here ();
  return u;
}

suffix() [1/2]

string suffix	(	url	u,
		bool	use_locase )

Definition at line 381 of file url.cpp.

                                {
  u= tail (u);
  if (!is_atomic (u)) return "";
  string s= as_string (u);
  int    i, n= N (s);
  for (i= n - 1; i >= 0; i--)
    if (s[i] == '.') break;
  if ((i > 0) && (i < n - 1)) {
    string r= s (i + 1, n);
    while ((N (r) > 0) && (r[N (r) - 1] == '~' || r[N (r) - 1] == '#'))
      r= r (0, N (r) - 1);
    int found= index_of (r, '?');
    if (found != -1) r= r (0, found);
    if (use_locase) return locase_all (r);
    else return r;
  }
  return "";
}

suffix() [2/2]

string suffix

(

url

u

)

Definition at line 401 of file url.cpp.

               {
  return suffix (u, true);
}

basename() [1/2]

string basename	(	url	u,
		string	suf )

Definition at line 406 of file url.cpp.

                             {
  string s    = as_string (tail (u));
  int    found= index_of (s, '?');
  if (found != -1) s= s (0, found);
  return remove_suffix (s, suf);
}

basename() [2/2]

string basename

(

url

u

)

Definition at line 414 of file url.cpp.

                 {
  string s= suffix (u, false);
  if (!is_empty (s)) s= "." * s;
  return basename (u, s);
}

glue()

url glue	(	url	u,
		string	s )

Definition at line 421 of file url.cpp.

                       {
  if (is_atomic (u)) return as_url (url_tree (u->t->label * s));
  if (is_concat (u)) return u[1] * glue (u[2], s);
  if (is_or (u)) return glue (u[1], s) | glue (u[2], s);
  if (is_none (u)) return u;
  TM_FAILED ("can't glue string to url");
  return u;
}

unglue()

url unglue	(	url	u,
		int	nr )

Definition at line 431 of file url.cpp.

                       {
  if (is_atomic (u))
    return as_url (url_tree (u->t->label (0, max (N (u->t->label) - nr, 0))));
  if (is_concat (u)) return u[1] * unglue (u[2], nr);
  if (is_or (u)) return unglue (u[1], nr) | unglue (u[2], nr);
  if (is_none (u)) return u;
  TM_FAILED ("can't unglue from url");
  return u;
}

unblank()

url unblank

(

url

u

)

Definition at line 442 of file url.cpp.

                {
  if (is_concat (u) && (u[2]->t == "")) return u[1];
  if (is_concat (u)) return u[1] * unblank (u[2]);
  if (is_or (u)) return unblank (u[1]) | unblank (u[2]);
  return u;
}

relative()

url relative	(	url	base,
		url	u )

Definition at line 450 of file url.cpp.

                           {
  return head (base) * u;
}

delta_sub()

url delta_sub	(	url	base,
		url	u )

Definition at line 455 of file url.cpp.

                            {
  if (is_atomic (base)) return u;
  if (is_concat (base) && is_concat (u) && (base[1] == u[1])) {
    if (is_special_root (base[1]) && is_concat (base[2]) && is_concat (u[2]) &&
        base[2][1] != u[2][1])
      return url_none ();
    return delta_sub (base[2], u[2]);
  }
  if (is_concat (base) && !is_semi_root (base))
    return url_parent () * delta_sub (head (base), u);
  return url_none ();
}

delta()

url delta	(	url	base,
		url	u )

Definition at line 469 of file url.cpp.

                        {
  if (is_or (u)) return delta (base, u[1]) | delta (base, u[2]);
  url res= delta_sub (base, u);
  if (is_none (res)) return u;
  return res;
}

get_root()

string get_root

(

url

u

)

Definition at line 477 of file url.cpp.

                 {
  return u.protocol ();
}

unroot()

url unroot

(

url

u

)

Definition at line 482 of file url.cpp.

               {
  if (is_concat (u)) return unroot (u[1]) * u[2];
  if (is_or (u)) return unroot (u[1]) | unroot (u[2]);
  if (is_root (u)) return url_here ();
  return u;
}

reroot()

url reroot	(	url	u,
		string	protocol )

Definition at line 490 of file url.cpp.

                                {
  if (is_concat (u)) return reroot (u[1], protocol) * u[2];
  if (is_or (u)) return reroot (u[1], protocol) | reroot (u[2], protocol);
  if (is_root (u)) return url_root (protocol);
  return u;
}

expand() [1/2]

static url expand ( url u1, url u2 )

static

Definition at line 498 of file url.cpp.

                        {
  if (is_or (u1)) return expand (u1[1], u2) | expand (u1[2], u2);
  if (is_or (u2)) return expand (u1, u2[1]) | expand (u1, u2[2]);
  if (is_ancestor (u2)) {
    if (is_concat (u1)) return u1 | expand (u1[1], u2);
    if (is_special_root (u1)) return u2;
    return u1 | u2;
  }
  if (is_concat (u2) && is_ancestor (u2[1]))
    return expand (expand (u1, u2[1]), u2[2]);
  return u1 * u2;
}

expand() [2/2]

url expand

(

url

u

)

Definition at line 512 of file url.cpp.

               {
  if (is_or (u)) return expand (u[1]) | expand (u[2]);
  if (is_concat (u)) return expand (expand (u[1]), expand (u[2]));
  return u;
}

operator<=()

static bool operator<= ( url u1, url u2 )

static

Definition at line 518 of file url.cpp.

                            {
  if (is_atomic (u1) && is_atomic (u2)) return u1->t->label <= u2->t->label;
  if (is_atomic (u1)) return true;
  if (is_atomic (u2)) return false;
  if (is_concat (u1) && is_concat (u2)) {
    if (u1[1] == u2[1]) return u1[2] <= u2[2];
    else return u1[1] <= u2[1];
  }
  if (is_concat (u1)) return true;
  if (is_concat (u2)) return false;
  return true; // does not matter for sorting
}

sort_sub()

static url sort_sub ( url add, url to )

static

Definition at line 533 of file url.cpp.

                           {
  if (is_or (to)) {
    if (add <= to[1]) return add | to;
    return to[1] | sort_sub (add, to[2]);
  }
  if (add <= to) return add | to;
  else return to | add;
}

sort()

url sort

(

url

u

)

Definition at line 543 of file url.cpp.

             {
  if (is_or (u)) return sort_sub (u[1], sort (u[2]));
  else return u;
}

factor_sorted()

static url factor_sorted ( url u )

static

Definition at line 549 of file url.cpp.

                      {
  if (!is_or (u)) return u;
  url v= factor_sorted (u[2]);
  if (is_concat (u[1])) {
    if (is_concat (v) && (u[1][1] == v[1])) return u[1][1] * (u[1][2] | v[2]);
    if (is_or (v) && is_concat (v[1]) && (u[1][1] == v[1][1]))
      return (u[1][1] * (u[1][2] | v[1][2])) | v[2];
  }
  return u[1] | v;
}

factor_sub()

static url factor_sub ( url u )

static

Definition at line 561 of file url.cpp.

                   {
  if (is_concat (u)) return u[1] * factor (u[2]);
  if (is_or (u)) return factor_sub (u[1]) | factor_sub (u[2]);
  return u;
}

factor()

url factor

(

url

u

)

Definition at line 568 of file url.cpp.

               {
  return factor_sub (factor_sorted (sort (u)));
}

descends()

bool descends	(	url	u,
		url	base )

Definition at line 573 of file url.cpp.

                           {
  if (u == base) return true;
  if (is_concat (u) && is_atomic (base)) return u[1] == base;
  if (is_concat (u) && is_concat (base)) {
    url iter_u= u, iter_base= base;
    while (iter_u[1] == iter_base[1]) {
      iter_u   = iter_u[2];
      iter_base= iter_base[2];
      if (is_concat (iter_u) && is_concat (iter_base)) {
        continue;
      }
      else {
        return descends (iter_u, iter_base);
      }
    }
    return false;
  }
  if (is_or (u)) return descends (u[1], base) && descends (u[2], base);
  if (is_or (base)) return descends (u, base[1]) || descends (u, base[2]);
  return false;
}

operator*() [1/3]

url operator*	(	url	u1,
		url	u2 )

Definition at line 596 of file url.cpp.

                           {
  if (is_root (u2) || (is_concat (u2) && is_root (u2[1]))) {
    if (is_concat (u1) && is_root_web (u1[1])) {
      if (is_root (u2, "default") ||
          (is_concat (u2) && is_root (u2[1], "default"))) {
        url v= u1[2];
        while (is_concat (v))
          v= v[1];
        if (is_root (u2)) return u1[1] * v;
        return u1[1] * v * u2[2];
      }
      if (is_root (u2, "blank") || (is_concat (u2) && is_root (u2[1], "blank")))
        return reroot (u2, u1[1][1]->t->label);
    }
    if (is_root (u1) && is_rooted (u1, "file")) {
      return u1 * u2[2];
    }
    return u2;
  }
  if (is_here (u1) || (u1->t == "")) return u2;
  if (is_here (u2)) return u1;
  if (is_none (u1)) return url_none ();
  if (is_none (u2)) return url_none ();
  if (u2 == url_parent ()) {
    if (is_root (u1)) return u1;
    if (is_pseudo_atomic (u1) && (!is_parent (u1))) return url_here ();
    if (is_semi_root (u1)) return u1;
  }
  if (is_concat (u2) && (u2[1] == url_parent ())) {
    if (is_root (u1)) return u1 * u2[2];
    if (is_pseudo_atomic (u1) && (!is_parent (u1))) return u2[2];
    if (is_semi_root (u1)) return u1 * u2[2];
  }
  if (is_concat (u1)) return u1[1] * (u1[2] * u2);
  return as_url (url_tuple ("concat", u1->t, u2->t));
}

operator*() [2/3]

url operator*	(	url	u1,
		const char *	name )

Definition at line 634 of file url.cpp.

                                     {
  return u1 * url (name);
}

operator*() [3/3]

url operator*	(	url	u1,
		string	name )

Definition at line 639 of file url.cpp.

                                {
  return u1 * url (name);
}

url_concat()

url url_concat	(	url	u1,
		url	u2 )

Definition at line 644 of file url.cpp.

                            {
  return u1 * u2;
}

operator|()

url operator|	(	url	u1,
		url	u2 )

Definition at line 649 of file url.cpp.

                           {
  if (is_none (u1)) return u2;
  if (is_none (u2)) return u1;
  if (is_or (u1)) return u1[1] | (u1[2] | u2);
  if (u1 == u2) return u2;
  if (is_or (u2) && (u1 == u2[1])) return u2;
  return as_url (url_tuple ("or", u1->t, u2->t));
}

url_or()

url url_or	(	url	u1,
		url	u2 )

Definition at line 659 of file url.cpp.

                        {
  return u1 | u2;
}

is_atomic()

bool is_atomic

(

url

u

)

Definition at line 664 of file url.cpp.

                  {
  return is_atomic (u->t);
}

is_root()

bool is_root	(	url	u,
		string	s )

Definition at line 668 of file url.cpp.

                          {
  return is_root (u) && (u[1]->t->label == s);
}

is_root_web()

bool is_root_web

(

url

u

)

Definition at line 672 of file url.cpp.

                    {
  return is_root (u, "http") || is_root (u, "https") || is_root (u, "ftp") ||
         is_root (u, "blank");
}

is_wildcard()

bool is_wildcard	(	url	u,
		int	n )

Definition at line 677 of file url.cpp.

                           {
  return is_tuple (u->t, "wildcard", n);
}

is_pseudo_atomic()

bool is_pseudo_atomic

(

url

u

)

Definition at line 681 of file url.cpp.

                         {
  return is_atomic (u->t) || is_tuple (u->t, "wildcard", 1);
}

is_rooted() [1/2]

bool is_rooted

(

url

u

)

Definition at line 686 of file url.cpp.

                  {
  return is_root (u) || (is_concat (u) && is_rooted (u[1])) ||
         (is_or (u) && is_rooted (u[1]) && is_rooted (u[2]));
}

is_rooted() [2/2]

bool is_rooted	(	url	u,
		string	protocol )

Definition at line 692 of file url.cpp.

                                   {
  return is_root (u, protocol) ||
         (is_concat (u) && is_rooted (u[1], protocol)) ||
         (is_or (u) && is_rooted (u[1], protocol) &&
          is_rooted (u[2], protocol));
}

is_rooted_web()

bool is_rooted_web

(

url

u

)

Definition at line 700 of file url.cpp.

                      {
  return is_root_web (u) || (is_concat (u) && is_rooted_web (u[1])) ||
         (is_or (u) && is_rooted_web (u[1]) && is_rooted_web (u[2]));
}

is_name()

bool is_name

(

url

u

)

Definition at line 706 of file url.cpp.

                {
  if (is_atomic (u)) return true;
  if (!is_concat (u)) return false;
  return is_name (u[1]) && is_name (u[2]);
}

is_rooted_name()

bool is_rooted_name

(

url

u

)

Definition at line 713 of file url.cpp.

                       {
  return is_concat (u) && is_root (u[1]) && is_name (u[2]);
}

is_name_in_path()

bool is_name_in_path

(

url

u

)

Definition at line 718 of file url.cpp.

                        {
  if (is_name (u)) return true;
  return is_concat (u) && is_root (u[1], "default") && is_name (u[2]);
}

is_ramdisc()

bool is_ramdisc

(

url

u

)

Definition at line 724 of file url.cpp.

                   {
  return is_concat (u) && is_root (u[1], "ramdisc");
}

as_string()

string as_string	(	url	u,
		int	type )

Definition at line 729 of file url.cpp.

                            {
  // This routine pretty prints an url as a string.
  // FIXME: the current algorithm is quadratic in time.
  if (is_none (u)) return "{}";
  if (is_atomic (u)) return u->t->label;
  if (is_concat (u)) {
    int stype= type;
    if (is_root (u[1]) &&
        !(is_root (u[1], "default") || is_root (u[1], "file"))) {
      stype= URL_STANDARD;
    }
    string sep= (stype == URL_SYSTEM ? string (URL_CONCATER) : string ("/"));
    string s1 = as_string (u[1], type);
    string s2 = as_string (u[2], stype);
    if (is_root (u[1], "default")) s1= "";
    if ((!is_name (u[1])) && (!is_root (u[1]))) s1= "{" * s1 * "}";
    if ((!is_concat (u[2])) && (!is_atomic (u[2])) && (!is_wildcard (u[2], 1)))
      s2= "{" * s2 * "}";
    if (os_win () && // have to return the windows format
        ((is_root (u[1], "default") && type == URL_SYSTEM) ||
         is_root (u[1], "file"))) {
      string root, remain;
      if (is_concat (u[2])) {
        root= as_string (u[2][1], type);
        // root might be unit letter or hostname. It depends on the length
        remain= as_string (u[2][2], type);
      }
      else {
        root  = s2;
        remain= "";
      }
      if (is_root (u[1], "default")) {
        if (N (root) == 1) return root * ":" * sep * remain; // drive letter
        else return "\\\\" * root * "\\" * remain;
      }
      else {
        if (N (root) == 1)
          return s1 * "/" * root * ":" * sep * remain; // local file
        else return s1 * root * "/" * remain;          // remote
      }
    }
    return s1 * sep * s2;
  }
  if (is_or (u)) {
    string s1= as_string (u[1], type);
    string s2= as_string (u[2], type);
    if (!is_name_in_path (u[1])) s1= "{" * s1 * "}";
    if ((!is_or (u[2])) && (!is_name_in_path (u[2]))) s2= "{" * s2 * "}";
    if (os_win ()) {
      if (type == URL_STANDARD) return s1 * ":" * s2;
      else return s1 * string (URL_SEPARATOR) * s2;
    }
    else {
      return s1 * string (URL_SEPARATOR) * s2;
    }
  }
  if (os_win ()) {
    if (is_root (u, "default")) {
      int stype= type;
      if (is_root (u[1]) && (!is_root (u[1], "default"))) stype= URL_STANDARD;
      if (stype == URL_SYSTEM) return "";
      else return "/";
    }
  }
  else {
    if (is_root (u, "default")) return "/";
  }
  if (is_root (u, "blank")) return "/";
  if (is_root (u, "file")) return u[1]->t->label * "://";
  if (is_root (u)) return u[1]->t->label * ":/";
  if (is_wildcard (u, 0)) return "**";
  if (is_wildcard (u, 1)) return u->t[1]->label;
  TM_FAILED ("bad url");
  return "";
}

operator<<()

tm_ostream & operator<<	(	tm_ostream &	out,
		url	u )

Definition at line 805 of file url.cpp.

                                    {
  return out << as_string (u, URL_SYSTEM);
}