Assign the URL by character string

Declared in file: hzUrl.h
Defined in file : hzUrl.cpp

Function Logic:

Function body:

hzUrl& hzUrl::operator= (const char* url)
{
   //  Assign the URL by character string
   //  
   //  Arguments: 1) url The whole URL as string
   //  
   //  Returns: Reference to this URL intance
   _hzfunc("hzUrl::operator=") ;
   _url_space* thisCtl ;           //  This URL space
   const char* pDom ;              //  Start of domain component
   const char* pRes ;              //  Start of resource component
   const char* _ptr ;              //  Char iterator
   uint32_t    lenProt = 0;        //  Length of protocol indicator (eg http://)
   uint32_t    lenDom = 0;     //  Length of domain name
   uint32_t    lenPort = 0;        //  Length of port indicator if present
   uint32_t    lenRes = 0;     //  Length of resource
   uint32_t    lenTotal ;          //  Length of whole string
   uint32_t    nPort = 80;     //  Port number
   uint32_t    nProto = 80;    //  Presumed port number of protocol
   uint32_t    nAlphas = 0;        //  Number of alphanum chars (must be at least one)
   uint32_t    nPeriod = 0;        //  Number of periods (must be at least one)
   uint32_t    nWhite = 0;     //  Number of whitespace chars
   bool        bPort = false ;     //  True only if a port component specified (:num)
   Clear() ;
   if (!url || !url[0])
       return *this ;
   //  threadLog("URL [%s]\n", url) ;
   //  Strip leading spaces to find real start
   for (_ptr = url ; *_ptr <&eq; CHAR_SPACE ; _ptr++) ;
   /*
   **  ** Handle protocol component - Remove http:// or https:// to get to domain
   **      */
   if (strstr(_ptr, "//"))
   {
       if      (!memcmp(_ptr, "http://", 7))   { nProto = nPort = 80;lenProt = 7; }
       else if (!memcmp(_ptr, "https://", 8))  { nProto = nPort = 443;lenProt= 8; }
       else if (!memcmp(_ptr, "ws://", 5))     { nProto = nPort = 80;lenProt = 5; }
       else if (!memcmp(_ptr, "wss://", 6)){ nProto = nPort = 443;lenProt= 6; }
       else if (!memcmp(_ptr, "ftp://", 6)){ nProto = nPort = 21;lenProt = 6; }
       else
       {
           hzerr(E_FORMAT, "Scheme not supported") ;
           return *this ;
       }
       _ptr += lenProt ;
   }
   pDom = _ptr ;
   /*
   **  ** Handle domain component: Read up to the end of the domain name. This could be the end of the test string or it
   **   ** could be a forward slash or a colon (for the port number)
   **      */
   for (; *_ptr ; lenDom++, _ptr++)
   {
       if (*_ptr == CHAR_COLON)    break ;
       if (*_ptr == CHAR_FWSLASH)  break ;
       if (*_ptr == CHAR_PERIOD)   { nPeriod++ ; continue ; }
       if (*_ptr == CHAR_MINUS)    { nAlphas++ ; continue ; }
       if (*_ptr <&eq; CHAR_SPACE)    { nWhite++ ; continue ; }
       nAlphas++ ;
   }
   //  Deal with failures
   if (nWhite)     { hzerr(E_FORMAT, "Has whitespace\n") ; return *this ; }
   if (!nPeriod)   { hzerr(E_FORMAT, "No periods\n") ; return *this ; }
   if (!nAlphas)   { hzerr(E_FORMAT, "No alphas\n") ; return *this ; }
   /*
   **  ** Handle port component: Deal with case where domain string is terminated by a port indicator
   **      */
   if (*_ptr == CHAR_COLON)
   {
       _ptr++ ;
       for (nPort = 0,lenPort++ ; IsDigit(*_ptr) ; lenPort++)
           { nPort *= 10;nPort += (*_ptr - ''0'');_ptr++ ; }
       if (nPort >&eq; 65536)
       {
           hzerr(E_FORMAT, "Bad port\n") ;
           return *this ;
       }
       bPort = true ;
   }
   //  Should now have a terminator (<= space) or the / marking start of resource
   if (*_ptr >&eq; CHAR_SPACE && *_ptr != CHAR_FWSLASH)
       return *this ;
   /*
   **  ** Handle resource component: Read up to end of resource
   **      */
   pRes = _ptr ;
   for (; *_ptr > '' ''&&*_ptr != CHAR_QUERY ; lenRes++, _ptr++) ;
   /*
   **  ** Compile finished URL
   **      */
   lenTotal = lenProt + lenDom + lenPort + lenRes ;
   m_addr = _urlAlloc(lenTotal + URL_FACTOR) ;
   thisCtl = _urlXlate(m_addr) ;
   //  Do control part
   thisCtl->m_copy = 1;                //  No copies
   thisCtl->m_lenProt = lenProt ;      //  Length of protocol component
   thisCtl->m_lenDom = lenDom ;        //  Length of domain component
   thisCtl->m_lenPort = lenPort ;      //  Length of port component
   thisCtl->m_lenRes = lenRes ;        //  MSB of length of resource component
   thisCtl->m_port = nPort ;           //  Port number
   //  Do protocol part
   if      (nProto == 80&&lenProt == 7)memcpy(thisCtl->m_data, "http://", lenProt) ;
   else if (nProto == 443&&lenProt== 8)memcpy(thisCtl->m_data, "https://", lenProt) ;
   else if (nProto == 80&&lenProt == 5)memcpy(thisCtl->m_data, "ws://", lenProt) ;
   else if (nProto == 443&&lenProt== 6)memcpy(thisCtl->m_data, "wss://", lenProt) ;
   else if (nProto == 21)  memcpy(thisCtl->m_data, "ftp://", lenProt) ;
   else
   {
       hzerr(E_FORMAT, "Bad scheme\n") ;
       return *this ;
   }
   //  Do domain part
   memcpy(thisCtl->m_data + lenProt, pDom, lenDom) ;
   //  Do port part
   if (bPort)
       sprintf(thisCtl->m_data + lenProt + lenDom, ":%d", nPort) ;
   //  Do resource part
   memcpy(thisCtl->m_data + lenProt + lenDom + lenPort, pRes, lenRes) ;
   thisCtl->m_data[lenTotal] = 0;
   return *this ;
}