File indexing completed on 2024-04-28 15:35:14

 /***************************************************************************
  *   Copyright (C) 2004 by Tomas Mecir                                     *
  *   kmuddy@kmuddy.org                                                     *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU Library General Public License as       *
  *   published by the Free Software Foundation; either version 2 of the    *
  *   License, or (at your option) any later version.                       *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU Library General Public License for more details.                  *
  ***************************************************************************/
 
 #include "centitymanager.h"
 
 #include "entitylist.h"
 
 cEntityManager::cEntityManager (bool noStdEntities)
 {
   reset (noStdEntities);
 }
 
 cEntityManager::~cEntityManager ()
 {
   entities.clear ();
 }
 
 void cEntityManager::reset (bool noStdEntities)
 {
   partent = "";
   entities.clear ();
   inEntity = false;
   
   if (noStdEntities)
     return;
   
   char s[2];
   s[1] = 0;
   //restore standard HTML entities
   for (int i = 0; i < NUM_MXP_ENTITIES; i++)
   {
     s[0] = ENTITY_DEF[i];
     entities[ENTITY_NAMES[i]] = s;
   }
 }
 
 //can this be the first letter of an entity?
 inline bool correct1 (char l)
 {
   return (((l >= 'a') && (l <= 'z')) || ((l >= 'A') && (l <= 'Z')) || (l == '#'));
 }
 
 //can this be a letter of entity?
 inline bool correctN (char l)
 {
   return (((l >= 'a') && (l <= 'z')) || ((l >= 'A') && (l <= 'Z')) || (l == '_') ||
       ((l >= '0') && (l <= '9')));
 }
 
 void cEntityManager::addEntity (const string &name, const string &value)
 {
   if (name.empty()) return;
 
   //add or modify the entity
   entities[name] = value;
 }
 
 void cEntityManager::deleteEntity (const string &name)
 {
   entities.erase (name);
 }
 
 string cEntityManager::entity (const string &name)
 {
   if (exists (name))
     return entities[name];
   //return empty string otherwise
   return empty_string;
 }
 
 string cEntityManager::expandEntities (const string &s, bool finished)
 {
   string s1;
 
   if (!partent.empty ())  //some unfinished entity is waiting...
     inEntity = true;
 
   string::const_iterator it;
   for (it = s.begin(); it != s.end(); ++it)
     if (inEntity)
     {
       char ch = *it;
       if (ch == ';')  //end of entity
       {
         inEntity = false;
         if (partent.empty()) //received &;
         {
           s1 += "&;";
         }
         else
         if (partent[0] == '_')  //invalid entity name - IGNORED
         {
           partent = "";
         }
         else
         if (partent[0] == '#')  //&#nnn; entity
         {
           //compute number
           int n = 0;
           string::iterator it2 = partent.begin();
           it2++;  //starting from second character
           for (; it2 != partent.end(); ++it2)
           {
             int x = *it2 - 48;
             if ((x < 0) || (x > 9)) //WRONG
             {
               n = 0;
               break;
             }
             n = n * 10 + x;
             if (n > 255)  //number too big!
             {
               n = 0;
               break;
             }
           }
           //verify number, IGNORE entity if it's wrong
           if ((n >= 32) && (n <= 255))
             s1 += (unsigned char) n;
           partent = "";
         }
         else
         {
           //now we have correct entity name, let's expand it, if possible :)
           if (entities.count (partent))
             s1 += entities[partent];
           else
             //keep the same string if the entity doesn't exist...
             s1 += "&" + partent + ";";
           partent = "";
         }
       }
       else if (ch == '&')
       //unterminated entity, new entity may start here
       {
         s1 += "&" + partent;
         partent = "";
         //isEntity remains set
       }
       else if ((partent.empty() && correct1(ch)) || ((!partent.empty()) && correctN(ch)))
       {
         partent += ch;
       }
       //this wasn't an entity after all
       else
       {
         inEntity = false;
         s1 += "&" + partent + ch;
         partent = "";
       }
     }
     else
     {
       if (*it == '&')
         inEntity = true;
       else
         //copy without change
         s1 += *it;
     }
   //string ends in an unterminated entity, but only if the string is finished
   if (inEntity && finished)
   {
     s1 += "&" + partent;
     partent = "";
     inEntity = false;
   }
 
   //return the resulting string
   return s1;
 }
 
 bool cEntityManager::needMoreText()
 {
   return partent.empty() ? false : true;
 }