swad-core/swad_string.c

// swad_string.c: string processing

/*
    SWAD (Shared Workspace At a Distance),
    is a web platform developed at the University of Granada (Spain),
    and used to support university teaching.

    This file is part of SWAD core.
    Copyright (C) 1999-2024 Antonio Ca<EFBFBD>as Vargas

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as
    published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/*****************************************************************************/
/********************************* Headers ***********************************/
/*****************************************************************************/

#define _GNU_SOURCE 		// For asprintf
#include <ctype.h>		// For isprint, isspace, etc.
#include <locale.h>		// For setlocale
#include <math.h>		// For log10, floor, ceil, modf, sqrt...
#include <stdio.h>		// For asprintf
#include <stdlib.h>		// For free
#include <string.h>		// For string functions

#include "swad_alert.h"
#include "swad_error.h"
#include "swad_global.h"
#include "swad_notification_database.h"
#include "swad_parameter.h"
#include "swad_string.h"

/*****************************************************************************/
/******************** Global variables from other modules ********************/
/*****************************************************************************/

extern struct Globals Gbl;

/*****************************************************************************/
/*************************** Private prototypes ******************************/
/*****************************************************************************/

static unsigned Str_FindHTMLEntity (const char *Ptr);

static int Str_ReadCharAndSkipComments (FILE *FileSrc,Str_SkipHTMLComments_t SkipHTMLComments);
static int Str_ReadCharAndSkipCommentsWriting (FILE *FileSrc,FILE *FileTgt,Str_SkipHTMLComments_t SkipHTMLComments);
static int Str_ReadCharAndSkipCommentsBackward (FILE *FileSrc,Str_SkipHTMLComments_t SkipHTMLComments);

/*****************************************************************************/
/**************************** Private constants ******************************/
/*****************************************************************************/

/***** Conversion to Base64URL *****/
// base64url is described in document http://tools.ietf.org/html/rfc4648.
// It uses '-' and '_' because they are safe for URL/parameters (without enconding) and for filenames.
const char Str_BIN_TO_BASE64URL[64 + 1] =
  {'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
   'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',
   '0','1','2','3','4','5','6','7','8','9','-','_',
   '\0'};	// NULL-terminated string

static const char Str_LF[2] = {10,0};
static const char Str_CR[2] = {13,0};

/*****************************************************************************/
/*********** Check if a character is in set { a-z, A-Z, 0-9, _ } *************/
/*****************************************************************************/

bool Str_ChIsAlphaNum (char Ch)
  {
   return ((Ch >= 'a' && Ch <= 'z') ||
	   (Ch >= 'A' && Ch <= 'Z') ||
	   (Ch >= '0' && Ch <= '9') ||
	   (Ch == '_'));
  }

/*****************************************************************************/
/** Get next ASCII character from a string converting &#number; to character */
/*****************************************************************************/
// Returns number of char analyzed

unsigned Str_GetNextASCIICharFromStr (const char *Ptr,unsigned char *Ch)
  {
   unsigned NumChars;
   unsigned Num;

   if (*Ptr == '\0')
     {
      *Ch = '\0';
      return 0;
     }
   else if (*Ptr == '&')	// It's a &#num; character?
     {
      Ptr++;
      if (*Ptr == '#')
        {
         Ptr++;
         for (NumChars = 2, Num = 0;
              *Ptr >= '0' && *Ptr <= '9';
              Ptr++, NumChars++)
            if (Num < 100000)	// To avoid overflow
               Num = Num * 10 + (unsigned) (*Ptr - '0');
         if (*Ptr == ';')	// &#num; found
           {
            NumChars++;
            switch (Num)
              {
               case  32: *Ch = ' ';  return NumChars;
               case  33: *Ch = '!';  return NumChars;
               case  34: *Ch = '\"'; return NumChars;
               case  35: *Ch = '#';  return NumChars;
               case  36: *Ch = '$';  return NumChars;
               case  37: *Ch = '%';  return NumChars;
               case  38: *Ch = '&';  return NumChars;
               case  39: *Ch = '\''; return NumChars;
               case  40: *Ch = '(';  return NumChars;
               case  41: *Ch = ')';  return NumChars;
               case  42: *Ch = '*';  return NumChars;
               case  43: *Ch = '+';  return NumChars;
               case  44: *Ch = ',';  return NumChars;
               case  45: *Ch = '-';  return NumChars;
               case  46: *Ch = '.';  return NumChars;
               case  47: *Ch = '/';  return NumChars;
               case  58: *Ch = ':';  return NumChars;
               case  59: *Ch = ';';  return NumChars;
               case  60: *Ch = ' ';  return NumChars;	// '<'
               case  61: *Ch = '=';  return NumChars;
               case  62: *Ch = ' ';  return NumChars;	// '>'
               case  63: *Ch = '?';  return NumChars;
               case  64: *Ch = '@';  return NumChars;
               case  91: *Ch = '[';  return NumChars;
               case  92: *Ch = '\\'; return NumChars;
               case  93: *Ch = ']';  return NumChars;
               case  94: *Ch = '^';  return NumChars;
               case  95: *Ch = '_';  return NumChars;
               case  96: *Ch = '`';  return NumChars;
               case 123: *Ch = '{';  return NumChars;
               case 124: *Ch = '|';  return NumChars;
               case 125: *Ch = '}';  return NumChars;
               case 126: *Ch = '~';  return NumChars;
               default:  *Ch = '?';  return NumChars;	// Unknown character
              }
           }
         else
           {
            *Ch = (unsigned char) *Ptr;
            return NumChars;
           }
        }
      else
        {
         *Ch = (unsigned char) *Ptr;
         return 2;
        }
     }
   else
     {
      *Ch = (unsigned char) *Ptr;
      return 1;
     }
  }

/*****************************************************************************/
/*************** Limit number of chars on screen of a string *****************/
/*****************************************************************************/
// Returns length of resulting string in bytes (a special char counts for several bytes)

size_t Str_LimitLengthHTMLStr (char *Str,size_t MaxCharsOnScreen)
  {
   char *Ptr;
   size_t NumCharsOnScreen;
   size_t Length;
   size_t LengthHTMLEntity;

   if (MaxCharsOnScreen < 3)
      MaxCharsOnScreen = 3;	// Length of "..."

   /***** Calculate length counting "&...;" as one character *****/
   for (Ptr = Str, NumCharsOnScreen = 0, Length = 0;
	*Ptr;
	Ptr++, NumCharsOnScreen++, Length++)
      /* Check if an HTML entity is present */
      if (*Ptr == '&')	// Possible HTML entity
	 if ((LengthHTMLEntity = Str_FindHTMLEntity (Ptr)))
	   {
	    /* if Ptr points to &ntilde; ==> Length = 8 */
	    Ptr    += LengthHTMLEntity - 1;	// Now Ptr point to ';'
	    Length += LengthHTMLEntity - 1;
	   }

   if (NumCharsOnScreen <= MaxCharsOnScreen)	// Don't limit string
      return Length;

   /***** Limit length of string *****/
   for (Ptr = Str, NumCharsOnScreen = 0, Length = 0;
	*Ptr;
	Ptr++, NumCharsOnScreen++, Length++)
     {
      if (NumCharsOnScreen == MaxCharsOnScreen - 3)
	{
         *Ptr++ = '.';
         *Ptr++ = '.';
         *Ptr++ = '.';
	 *Ptr   = '\0';		// ...limit length...
	 Length += 3;
         break;
	}
      /* Check if an HTML entity or directive is present */
      if (*Ptr == '&')	// Possible HTML entity
	{
	 if ((LengthHTMLEntity = Str_FindHTMLEntity (Ptr)))
	   {
	    /* if Ptr points to &ntilde; ==> Length = 8 */
	    Ptr += LengthHTMLEntity - 1;	// Now Ptr point to ';'
	    Length += LengthHTMLEntity - 1;
	   }
	}
      else if (*Ptr == '<')	// HTML directive "<...>"
	 for (Ptr++, Length++;
	      *Ptr && *Ptr != '>';
	      Ptr++, Length++);	// While not end of HTML directive "<...>"
     }

   return Length;
  }

/*****************************************************************************/
/******** Return the length of a possible HTML entity inside a string ********/
/*****************************************************************************/
// For example, if Ptr points to "&ntilde;..." or "&#38754;...", return 8
// If Ptr points to no HTML entity, return 0

static unsigned Str_FindHTMLEntity (const char *Ptr)
  {
   size_t Length = 0;
   char Ch;

   /***** The first character must be '&' *****/
   if (Ptr[Length] != '&')
      return 0;	// No HTML entity found

   /***** The second character can be '#' *****/
   Length++;
   if (Ptr[Length] == '#')
      /* Go to third character */
      Length++;

   /***** Now one or more alphanumeric characters are expected *****/
   /* Check second/third character */
   Ch = Ptr[Length];
   if (!((Ch >= '0' && Ch <= '9') ||
	 (Ch >= 'a' && Ch <= 'z') ||
	 (Ch >= 'A' && Ch <= 'Z')))
      return 0;	// No HTML entity found

   /* Go to first non alphanumeric character */
   do
     {
      Length++;
      Ch = Ptr[Length];
     }
   while ((Ch >= '0' && Ch <= '9') ||
	  (Ch >= 'a' && Ch <= 'z') ||
	  (Ch >= 'A' && Ch <= 'Z'));

   /***** An HTML entity must end by ';' *****/
   return (Ptr[Length] == ';') ? Length + 1 :	// HTML entity found (return Length including the final ';')
	                         0;		// No HTML entity found
  }

/*****************************************************************************/
/*** Create a notification about mention for any nickname in a publication ***/
/*****************************************************************************/
/*
 Example: "The user @rms says..."
                     ^ ^
         PtrStart ___| |___ PtrEnd
                 Length = 3
*/
void Str_AnalyzeTxtAndStoreNotifyEventToMentionedUsrs (long PubCod,const char *Txt)
  {
   const char *Ptr;
   bool IsNickname;
   struct
     {
      const char *PtrStart;
      const char *PtrEnd;
      size_t Length;		// Length of the nickname
     } Nickname;
   struct Usr_Data UsrDat;
   bool CreateNotif;
   bool NotifyByEmail;

   /***** Initialize structure with user's data *****/
   Usr_UsrDataConstructor (&UsrDat);

   /***** Find nicknames and create notifications *****/
   for (Ptr = Txt;
	*Ptr;)
      /* Check if the next char is the start of a nickname */
      if ((int) *Ptr == (int) '@')
	{
	 /* Find nickname end */
	 Ptr++;	// Points to first character after @
         Nickname.PtrStart = Ptr;

	 /* A nick can have digits, letters and '_'  */
	 for (;
	      *Ptr;
	      Ptr++)
	    if (!((*Ptr >= 'a' && *Ptr <= 'z') ||
		  (*Ptr >= 'A' && *Ptr <= 'Z') ||
		  (*Ptr >= '0' && *Ptr <= '9') ||
		  (*Ptr == '_')))
	       break;

	 /* Calculate length of this nickname */
	 Nickname.PtrEnd = Ptr - 1;
         Nickname.Length = (size_t) (Ptr - Nickname.PtrStart);

	 /* A nick (without arroba) must have a number of characters
            Nck_MIN_CHARS_NICK_WITHOUT_ARROBA <= Length <= Nck_MAX_CHARS_NICK_WITHOUT_ARROBA */
	 IsNickname = (Nickname.Length >= Nck_MIN_CHARS_NICK_WITHOUT_ARROBA &&
	               Nickname.Length <= Nck_MAX_CHARS_NICK_WITHOUT_ARROBA);

	 if (IsNickname)
	   {
	    /* Copy nickname */
	    strncpy (UsrDat.Nickname,Nickname.PtrStart,Nickname.Length);
	    UsrDat.Nickname[Nickname.Length] = '\0';

	    if ((UsrDat.UsrCod = Nck_GetUsrCodFromNickname (UsrDat.Nickname)) > 0)
	       if (Usr_ItsMe (UsrDat.UsrCod) == Usr_OTHER)	// Not me
		 {
		  /* Get user's data */
		  Usr_GetAllUsrDataFromUsrCod (&UsrDat,
		                               Usr_DONT_GET_PREFS,
		                               Usr_DONT_GET_ROLE_IN_CRS);

		  /* Create notification for the mentioned user *****/
		  CreateNotif = (UsrDat.NtfEvents.CreateNotif & (1 << Ntf_EVENT_TML_MENTION));
		  if (CreateNotif)
		    {
		     NotifyByEmail = (UsrDat.NtfEvents.SendEmail & (1 << Ntf_EVENT_TML_MENTION));
		     Ntf_DB_StoreNotifyEventToUsr (Ntf_EVENT_TML_MENTION,UsrDat.UsrCod,PubCod,
						   (Ntf_Status_t) (NotifyByEmail ? Ntf_STATUS_BIT_EMAIL :
										   0),
						   Gbl.Hierarchy.Node[Hie_INS].HieCod,
						   Gbl.Hierarchy.Node[Hie_CTR].HieCod,
						   Gbl.Hierarchy.Node[Hie_DEG].HieCod,
						   Gbl.Hierarchy.Node[Hie_CRS].HieCod);
		    }
		 }
	   }
	}
      /* The next char is not the start of a nickname */
      else	// Character != '@'
         Ptr++;

   /***** Free memory used for user's data *****/
   Usr_UsrDataDestructor (&UsrDat);
  }

/*****************************************************************************/
/***** Convert a string to title: first uppercase and the rest lowercase *****/
/*****************************************************************************/

void Str_ConvertToTitleType (char *Str)
  {
   char Ch;
   char *Ptr;
   char *Ptr2;
   unsigned LengthStr;
   bool FirstLetter = true;

   for (Ptr = Str;
	*Ptr;
	Ptr++)
     {
      Ch = *Ptr;
      if (isspace ((int) Ch) ||
	  Ch == '\xA0' ||	// Unicode translation for &nbsp;
	  Ch ==    '-' ||
	  Ch ==    '(' ||
	  Ch ==    ')' ||
	  Ch ==    ',' ||
       // Ch ==    ';' ||	// Do not start a new word on ';'.
				// Example: akto&#287;an should be converted to Akto&#287;an
	  Ch ==    '.' ||
	  Ch ==    ':' ||
	  Ch ==    '<EFBFBD>' ||
	  Ch ==    '<EFBFBD>')
	 FirstLetter = true;
      else
	{
	 if (FirstLetter)
	   {
	    /* Check if it's "de", "del", "la", "y" */	// This should be internationalized!!!!!
	    for (Ptr2 = Ptr, LengthStr = 0;
		 *Ptr2;
		 Ptr2++, LengthStr++)
	       if (isspace ((int) *Ptr2) ||
		   *Ptr2 == '\xA0')	// Unicode translation for &nbsp;
		  break;
	    if (LengthStr == 1)
	      {
	       if (!strncasecmp (Ptr,"y",1))
		  FirstLetter = false;
	      }
	    else if (LengthStr == 2)
	      {
	       if (!strncasecmp (Ptr,"de",2))
		  FirstLetter = false;
	       else if (!strncasecmp (Ptr,"la",2))
		  FirstLetter = false;
	      }
	    else if (LengthStr == 3)
	       if (!strncasecmp (Ptr,"del",3))
		  FirstLetter = false;
	   }
	 if (FirstLetter)
	   {
	    *Ptr = Str_ConvertToUpperLetter (*Ptr);
	    FirstLetter = false;
	   }
	 else
	    *Ptr = Str_ConvertToLowerLetter (*Ptr);
	}
     }
  }

/*****************************************************************************/
/*** Changes a string to made it comparable with others (removing tildes) ****/
/*****************************************************************************/

void Str_ConvertToComparable (char *Str)
  {
   char *Ptr;

   for (Ptr = Str;
	*Ptr;
	Ptr++)
     {
      *Ptr = Str_ConvertToLowerLetter (*Ptr);
      switch (*Ptr)
	{
	 case '<EFBFBD>': *Ptr = 'a'; break;
	 case '<EFBFBD>': *Ptr = 'e'; break;
	 case '<EFBFBD>': *Ptr = 'i'; break;
	 case '<EFBFBD>': *Ptr = 'o'; break;
	 case '<EFBFBD>': *Ptr = 'u'; break;
	 case '<EFBFBD>': *Ptr = 'a'; break;
	 case '<EFBFBD>': *Ptr = 'e'; break;
	 case '<EFBFBD>': *Ptr = 'i'; break;
	 case '<EFBFBD>': *Ptr = 'o'; break;
	 case '<EFBFBD>': *Ptr = 'u'; break;
	}
     }
  }

/*****************************************************************************/
/********************** Convert a string to uppercase ************************/
/*****************************************************************************/

char *Str_ConvertToUpperText (char *Str)
  {
   char *Ptr;

   for (Ptr = Str;
	*Ptr;
	Ptr++)
      *Ptr = Str_ConvertToUpperLetter (*Ptr);

   return Str;
  }

/*****************************************************************************/
/********************** Convert a string to lowercase ************************/
/*****************************************************************************/

char *Str_ConvertToLowerText (char *Str)
  {
   char *Ptr;

   for (Ptr = Str;
	*Ptr;
	Ptr++)
      *Ptr = Str_ConvertToLowerLetter (*Ptr);

   return Str;
  }

/*****************************************************************************/
/*********************** Convert a character to uppercase ********************/
/*****************************************************************************/

char Str_ConvertToUpperLetter (char Ch)
  {
   switch (Ch)
     {
      case '<EFBFBD>': return '<EFBFBD>';
      case '<EFBFBD>': return '<EFBFBD>';
      case '<EFBFBD>': return '<EFBFBD>';
      case '<EFBFBD>': return '<EFBFBD>';
      case '<EFBFBD>': return '<EFBFBD>';
      case '<EFBFBD>': return '<EFBFBD>';
      case '<EFBFBD>': return '<EFBFBD>';
      case '<EFBFBD>': return '<EFBFBD>';
      case '<EFBFBD>': return '<EFBFBD>';
      case '<EFBFBD>': return '<EFBFBD>';
      case '<EFBFBD>': return '<EFBFBD>';
      case '<EFBFBD>': return '<EFBFBD>';
      default: return (char) toupper ((int) Ch);
     }
  }

/*****************************************************************************/
/*********************** Convert a character to lowercase ********************/
/*****************************************************************************/

char Str_ConvertToLowerLetter (char Ch)
  {
   switch (Ch)
     {
      case '<EFBFBD>': return '<EFBFBD>';
      case '<EFBFBD>': return '<EFBFBD>';
      case '<EFBFBD>': return '<EFBFBD>';
      case '<EFBFBD>': return '<EFBFBD>';
      case '<EFBFBD>': return '<EFBFBD>';
      case '<EFBFBD>': return '<EFBFBD>';
      case '<EFBFBD>': return '<EFBFBD>';
      case '<EFBFBD>': return '<EFBFBD>';
      case '<EFBFBD>': return '<EFBFBD>';
      case '<EFBFBD>': return '<EFBFBD>';
      case '<EFBFBD>': return '<EFBFBD>';
      case '<EFBFBD>': return '<EFBFBD>';
      default: return (char) tolower ((int) Ch);
     }
  }

/*****************************************************************************/
/****************** Write a number in floating point *************************/
/*****************************************************************************/
// Str should be freed after calling this function

void Str_DoubleNumToStr (char **Str,double Number)
  {
   if (asprintf (Str,"%.15lg",
		 Number) < 0)
      Err_NotEnoughMemoryExit ();
  }

/*****************************************************************************/
/******* Write a number in floating point with few digits to a string ********/
/*****************************************************************************/
// Str should be freed after calling this function

void Str_DoubleNumToStrFewDigits (char **Str,double Number)
  {
   double IntegerPart;
   double FractionaryPart;
   char *Format;

   FractionaryPart = fabs (modf (Number,&IntegerPart));

   if (FractionaryPart == 0.0)
     {
      if (asprintf (Str,"%.0f",IntegerPart) < 0)
	 Err_NotEnoughMemoryExit ();
     }
   else
     {
      if (IntegerPart != 0.0)
         Format = "%.1lf";
      else if (FractionaryPart >= 0.095)
         Format = "%.2lf";
      else if (FractionaryPart >= 0.0095)
         Format = "%.3lf";
      else if (FractionaryPart >= 0.00095)
         Format = "%.4lf";
      else if (FractionaryPart >= 0.000095)
         Format = "%.5lf";
      else if (FractionaryPart >= 0.0000095)
         Format = "%.6lf";
      else
         Format = "%le";
      if (asprintf (Str,Format,Number) < 0)
	 Err_NotEnoughMemoryExit ();
     }
  }

/*****************************************************************************/
/********** Convert a string that holds a number in floating comma ***********/
/********** to another in floating point changing commas to points ***********/
/*****************************************************************************/

void Str_ConvertStrFloatCommaToStrFloatPoint (char *Str)
  {
   for (;
	*Str;
	Str++)
      if (*Str == ',')
        *Str = '.';
  }

/*****************************************************************************/
/************************ Get a double from a string *************************/
/*****************************************************************************/
// This function may change Str on wrong double

double Str_GetDoubleFromStr (const char *Str)
  {
   char *StrPoint;
   double DoubleNum;

   /***** Trivial check *****/
   if (Str == NULL)	// If no string...
      return 0.0;	// ...the number is reset to 0

   /***** Copy source string to temporary string to convert to point *****/
   if (asprintf (&StrPoint,"%s",Str) < 0)
      Err_NotEnoughMemoryExit ();

   /***** The string is "scanned" in floating point
          (it must have a point, not a comma as decimal separator) *****/
   Str_ConvertStrFloatCommaToStrFloatPoint (StrPoint);
   Str_SetDecimalPointToUS ();		// To get the decimal point as a dot
   if (sscanf (StrPoint,"%lf",&DoubleNum) != 1)	// If the string does not hold a valid number...
      DoubleNum = 0.0;				// ...the number is reset to 0
   Str_SetDecimalPointToLocal ();	// Return to local system

   /***** Free temporary string *****/
   free (StrPoint);

   return DoubleNum;
  }

/*****************************************************************************/
/**** Change decimal point to US system in order to get/print it as a dot ****/
/*****************************************************************************/

void Str_SetDecimalPointToUS (void)
  {
   if (!setlocale (LC_NUMERIC,"en_US.utf8"))	// To get/print the floating point as a dot
      if (Gbl.Layout.HTMLStartWritten)
         Ale_ShowAlert (Ale_ERROR,"Can not set locale to en_US.");
  }

/*****************************************************************************/
/****************** Change decimal point to local system *********************/
/*****************************************************************************/

void Str_SetDecimalPointToLocal (void)
  {
   // TODO: this should be internationalized!!!!!!!
   if (!setlocale (LC_NUMERIC,"es_ES.utf8"))	// Return to local system
      if (Gbl.Layout.HTMLStartWritten)
         Ale_ShowAlert (Ale_ERROR,"Can not set locale to es_ES.");
  }

/*****************************************************************************/
/*************** Add a string to a Query, changing ' for &#39; ***************/
/*****************************************************************************/

void Str_AddStrToQuery (char *Query,const char *Str,size_t SizeOfQuery)
  {
   size_t LengthOfQuery = strlen (Query);
   size_t SizeOfQuery_6 = SizeOfQuery - 6;
   size_t SizeOfQuery_2 = SizeOfQuery - 2;

   // Query can not have a ' character
   for (;
	*Str;
	Str++)
      if (*Str == '\'')	// It's a ' ...
        {
         if (LengthOfQuery > SizeOfQuery_6)
            break;
         Query[LengthOfQuery++] = '&';
         Query[LengthOfQuery++] = '#';
         Query[LengthOfQuery++] = '3';
         Query[LengthOfQuery++] = '9';
         Query[LengthOfQuery++] = ';';	// ...add the HTML special character &#39;
        }
      else		// It's another character...
        {
         if (LengthOfQuery > SizeOfQuery_2)
            break;
         Query[LengthOfQuery++] = *Str;	// ...add the character without changes
        }
   Query[LengthOfQuery] = '\0';
  }

/*****************************************************************************/
/******************** Change the format of a string **************************/
/*****************************************************************************/
/*
ChangeFrom can be:
Str_FROM_FORM
Str_FROM_TEXT
Str_FROM_HTML
ChangeTo can be:
Str_DONT_CHANGE
Str_TO_TEXT
Str_TO_MARKDOWN
Str_TO_HTML
Str_TO_RIGOROUS_HTML
For example the string "Nueva++de+San+Ant%F3n"
      is converted to:
      "Nueva &nbsp;de San Ant<6E>n"		if ChangeTo == Str_TO_RIGOROUS_HTML
      "Nueva  de San Ant<6E>n"			if ChangeTo == Str_TO_HTML
      "Nueva  de San Ant<6E>n"			if ChangeTo == Str_TO_TEXT
*/
#define Str_MAX_BYTES_SPECIAL_CHAR (256 - 1)

void Str_ChangeFormat (Str_ChangeFrom_t ChangeFrom,Str_ChangeTo_t ChangeTo,
                       char *Str,size_t MaxLengthStr,
                       Str_RemoveSpaces_t RemoveLeadingAndTrailingSpaces)
  {
   char *StrDst;
   char *PtrSrc;
   char *PtrDst;
   unsigned char Ch;
   unsigned int SpecialChar;
   size_t LengthSpecStrSrc = 0;
   size_t LengthSpecStrDst;
   unsigned long LengthStrDst = 0;
   unsigned NumSpacesTab;
   unsigned i;
   unsigned NumPrintableCharsFromReturn = 0;	// To substitute tabs for spaces
   bool IsSpecialChar = false;
   bool ThereIsSpaceChar = true;	// Indicates if the character before was a space. Set to true to respect the initial spaces.
   char StrSpecialChar[Str_MAX_BYTES_SPECIAL_CHAR + 1];

   if (ChangeTo != Str_DONT_CHANGE)
     {
      /***** Allocate memory for a destination string where to do the changes *****/
      if ((StrDst = malloc (MaxLengthStr + 1)) == NULL)
         Err_NotEnoughMemoryExit ();

      /***** Make the change *****/
      for (PtrSrc = Str, PtrDst = StrDst;
	   *PtrSrc;)
        {
         Ch = (unsigned char) *PtrSrc;
         switch (ChangeFrom)
           {
            case Str_FROM_FORM:
               switch (Par_GetContentReceivedByCGI ())
                 {
		  case Act_NORM:
		     // The form contained text and was sent with content type application/x-www-form-urlencoded
		     switch (Ch)
		       {
			case '+':	/* Change every '+' to a space */
			   IsSpecialChar = true;
			   LengthSpecStrSrc = 1;
			   SpecialChar = 0x20;
			   break;
			case '%':	/* Change "%XX" --> "&#decimal_number;" (from 0 to 255) */
				   /* Change "%uXXXX" --> "&#decimal number;  (from 0 to 65535) */
			   IsSpecialChar = true;
			   if (*(PtrSrc + 1) == 'u')
			     {
			      sscanf (PtrSrc + 2,"%4X",&SpecialChar);
			      LengthSpecStrSrc = 6;
			     }
			   else
			     {
			      sscanf (PtrSrc + 1,"%2X",&SpecialChar);
			      LengthSpecStrSrc = 3;
			     }
			   /* Some special characters, like a chinese character,
			      can be received from a form in a format like this:
			      %26%2335753%3B --> %26 %23 3 5 7 5 3 %3B --> &#35753;
						  ^   ^             ^
						  |   |             |
					 SpecialChar SpecialChar SpecialChar
			      Here one chinese character is converted
			      to 2 special chars + 5 normal chars + 1 special char,
			      and finally is stored as the following 8 bytes: &#35753;
			   */
			   break;
			case 0x27:	/* Change single comilla --> "&#39;" to avoid SQL code injection */
			case 0x5C:	/* '\\' */
			   IsSpecialChar = true;
			   LengthSpecStrSrc = 1;
			   SpecialChar = (unsigned int) Ch;
			   break;
			default:
			   IsSpecialChar = false;
			   NumPrintableCharsFromReturn++;
			   ThereIsSpaceChar = false;
			   break;
		       }
                     break;
		  case Act_DATA:
		     // The form contained data and was sent with content type multipart/form-data
		     switch (Ch)
		       {
			case 0x20:	/* Space */
			case 0x22:	/* Change double comilla --> "&#34;" */
			case 0x23:	/* '#' */
			case 0x26:	/* Change '&' --> "&#38;" */
			case 0x27:	/* Change single comilla --> "&#39;" to avoid SQL code injection */
			case 0x2C:	/* ',' */
			case 0x2F:	/* '/' */
			case 0x3A:	/* ':' */
			case 0x3B:	/* ';' */
			case 0x3C:	/* '<' --> "&#60;" */
			case 0x3E:	/* '>' --> "&#62;" */
			case 0x3F:	/* '?' */
			case 0x40:	/* '@' */
			case 0x5C:	/* '\\' */
			   IsSpecialChar = true;
			   LengthSpecStrSrc = 1;
			   SpecialChar = (unsigned int) Ch;
			   break;
			default:
			   if (Ch < 0x20 || Ch > 0x7F)
			     {
			      IsSpecialChar = true;
			      LengthSpecStrSrc = 1;
			      SpecialChar = (unsigned int) Ch;
			     }
			   else
			     {
			      IsSpecialChar = false;
			      NumPrintableCharsFromReturn++;
			      ThereIsSpaceChar = false;
			     }
			   break;
		       }
		     break;
                 }
               break;
            case Str_FROM_HTML:
            case Str_FROM_TEXT:
               switch (Ch)
                 {
                  case 0x20:	/* Space */
                  case 0x27:	/* Change single comilla --> "&#39;" to avoid SQL code injection */
                  case 0x5C:	/* '\\' */
                     IsSpecialChar = true;
                     LengthSpecStrSrc = 1;
                     SpecialChar = (unsigned int) Ch;
                     break;
                  default:
                     if (Ch < 0x20)
                       {
                        IsSpecialChar = true;
                        LengthSpecStrSrc = 1;
                        SpecialChar = (unsigned int) Ch;
                       }
                     else
                       {
                        IsSpecialChar = false;
                        NumPrintableCharsFromReturn++;
                        ThereIsSpaceChar = false;
                       }
                     break;
                 }
               break;
           }

         if (IsSpecialChar)
           {
            switch (SpecialChar)
              {
               case 0x09:  /* Tab */
                  if (ChangeTo == Str_TO_RIGOROUS_HTML)
                    {
                     /* Change tab to spaces (so many spaces as left until the next multiple of 8) */
                     StrSpecialChar[0] = '\0';
                     NumSpacesTab = 8 - NumPrintableCharsFromReturn % 8;
                     // Insert a space to separate former string from &nbsp;
                     // This space is not printed on screen in HTML,
                     // but it is necessary to mark the end of a possible previous URL
                     Str_Concat (StrSpecialChar,
                                 ThereIsSpaceChar ? "&nbsp;" :
                        	                    " ",	// The first space
                                 sizeof (StrSpecialChar) - 1);
                     for (i = 1;
                	  i < NumSpacesTab;
                	  i++)					// Rest of spaces, except the first
                        Str_Concat (StrSpecialChar,"&nbsp;",	// Add a space
                                    sizeof (StrSpecialChar) - 1);
                     NumPrintableCharsFromReturn += NumSpacesTab;
                    }
                  else
                    {
                     StrSpecialChar[0] = '\t';
                     StrSpecialChar[1] = '\0';
                    }
                  ThereIsSpaceChar = true;
                  break;
               case 0x0A:  /* \n */
        	  if (ChangeTo == Str_TO_RIGOROUS_HTML)
                     Str_Copy (StrSpecialChar,"<br />",
                               sizeof (StrSpecialChar) - 1);
        	  else
                    {
                     StrSpecialChar[0] = Str_LF[0];
                     StrSpecialChar[1] = '\0';
                    }
                  NumPrintableCharsFromReturn = 0;
                  ThereIsSpaceChar = true;
                  break;
               case 0x0D:  /* "%0D" --> "" */
        	  if (ChangeTo == Str_TO_RIGOROUS_HTML)
                     StrSpecialChar[0] = '\0';
        	  else
                    {
                     StrSpecialChar[0] = Str_CR[0];
                     StrSpecialChar[1] = '\0';
                    }
                  NumPrintableCharsFromReturn = 0;
                  ThereIsSpaceChar = true;
                  break;
               case 0x20:  /* Space */
        	  if (ChangeTo == Str_TO_RIGOROUS_HTML && ThereIsSpaceChar)
                     Str_Copy (StrSpecialChar,"&nbsp;",
                               sizeof (StrSpecialChar) - 1);
        	  else
                    {
                     StrSpecialChar[0] = ' ';
                     StrSpecialChar[1] = '\0';
                    }
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = true;
                  break;
               case 0x22:  /* "%22" --> "&#34;" (double comilla) */
        	  if (ChangeTo == Str_TO_MARKDOWN)
        	    {	// Escape sequence for database, two characters
        	     StrSpecialChar[0] = '\\';	// 1. An inverted bar
        	     StrSpecialChar[1] = '\"';	// 2. A double comilla
        	     StrSpecialChar[2] = '\0';	// End of string
        	    }
        	  else
                     Str_Copy (StrSpecialChar,"&#34;",	// Double comilla is stored as HTML code to avoid problems when displaying it
                	       sizeof (StrSpecialChar) - 1);
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0x23:  /* "%23" --> "#" */
		  StrSpecialChar[0] = '#';	// '#' must be converted to '#' to allow HTML entities like &#20998;
		  StrSpecialChar[1] = '\0';
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0x26:  /* "%26" --> "&" */
		  StrSpecialChar[0] = '&';	// '&' must be converted to '&' to allow HTML entities like &#20998;
		  StrSpecialChar[1] = '\0';
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0x27:  /* "%27" --> "&#39;" (single comilla) */
        	  if (ChangeTo == Str_TO_MARKDOWN)
        	    {	// Escape sequence for database, two characters
        	     StrSpecialChar[0] = '\\';	// 1. An inverted bar
        	     StrSpecialChar[1] = '\'';	// 2. A single comilla
        	     StrSpecialChar[2] = '\0';	// End of string
        	    }
        	  else
                     Str_Copy (StrSpecialChar,"&#39;",	// Single comilla is stored as HTML entity to avoid problem when querying database (SQL code injection)
                	       sizeof (StrSpecialChar) - 1);
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0x2C:  /* "%2C" --> "," */
		  StrSpecialChar[0] = ',';
		  StrSpecialChar[1] = '\0';
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0x2F:  /* "%2F" --> "/" */
		  StrSpecialChar[0] = '/';
		  StrSpecialChar[1] = '\0';
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0x3A:  /* "%3A" --> ":" */
		  StrSpecialChar[0] = ':';
		  StrSpecialChar[1] = '\0';
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0x3B:  /* "%3B" --> ";" */
		  StrSpecialChar[0] = ';';	// ';' must be converted to ';' to allow HTML entities like &#20998;
		  StrSpecialChar[1] = '\0';
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0x3C:  /* "%3C" --> "&#60;" (<) */
        	  if (ChangeTo == Str_TO_MARKDOWN)
        	    {
		     StrSpecialChar[0] = '<';
		     StrSpecialChar[1] = '\0';
        	    }
        	  else
                     Str_Copy (StrSpecialChar,"&#60;", // "<" is stored as HTML code to avoid problems when displaying it
                               sizeof (StrSpecialChar) - 1);
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0x3E:  /* "%3E" --> "&#62;" (>) */
        	  if (ChangeTo == Str_TO_MARKDOWN)
        	    {
		     StrSpecialChar[0] = '>';
		     StrSpecialChar[1] = '\0';
        	    }
        	  else
        	     Str_Copy (StrSpecialChar,"&#62;", // ">" is stored as HTML code to avoid problems when displaying it
        	               sizeof (StrSpecialChar) - 1);
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0x3F:  /* "%3F" --> "?" */
		  StrSpecialChar[0] = '?';
		  StrSpecialChar[1] = '\0';
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0x40:  /* "%40" --> "@" */
		  StrSpecialChar[0] = '@';
		  StrSpecialChar[1] = '\0';
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0x5C:  /* "%5C" --> "&#92;" (\) */
        	  if (ChangeTo == Str_TO_MARKDOWN)
        	    {	// Escape sequence for database, two characters
        	     StrSpecialChar[0] = '\\';	// 1. An inverted bar
        	     StrSpecialChar[1] = '\\';	// 2. An inverted bar
        	     StrSpecialChar[2] = '\0';	// End of string
        	    }
        	  else
                     Str_Copy (StrSpecialChar,"&#92;", // "\" is stored as HTML code to avoid problems when displaying it
                               sizeof (StrSpecialChar) - 1);
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0xC1:  /* "%C1" --> "<22>" */
		  StrSpecialChar[0] = '<EFBFBD>';
		  StrSpecialChar[1] = '\0';
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0xC9:  /* "%C9" --> "<22>" */
		  StrSpecialChar[0] = '<EFBFBD>';
		  StrSpecialChar[1] = '\0';
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0xCD:  /* "%CD" --> "<22>" */
		  StrSpecialChar[0] = '<EFBFBD>';
		  StrSpecialChar[1] = '\0';
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0xD3:  /* "%D3" --> "<22>" */
		  StrSpecialChar[0] = '<EFBFBD>';
		  StrSpecialChar[1] = '\0';
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0xDA:  /* "%DA" --> "<22>" */
		  StrSpecialChar[0] = '<EFBFBD>';
		  StrSpecialChar[1] = '\0';
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0xD1:  /* "%D1" --> "<22>" */
		  StrSpecialChar[0] = '<EFBFBD>';
		  StrSpecialChar[1] = '\0';
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0xC7:  /* "%C7" --> "<22>" */
		  StrSpecialChar[0] = '<EFBFBD>';
		  StrSpecialChar[1] = '\0';
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0xE1:  /* "%E1" --> "<22>" */
		  StrSpecialChar[0] = '<EFBFBD>';
		  StrSpecialChar[1] = '\0';
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0xE9:  /* "%E9" --> "<22>" */
		  StrSpecialChar[0] = '<EFBFBD>';
		  StrSpecialChar[1] = '\0';
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0xED:  /* "%ED" --> "<22>" */
		  StrSpecialChar[0] = '<EFBFBD>';
		  StrSpecialChar[1] = '\0';
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0xF3:  /* "%F3" --> "<22>" */
		  StrSpecialChar[0] = '<EFBFBD>';
		  StrSpecialChar[1] = '\0';
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0xFA:  /* "%FA" --> "<22>" */
		  StrSpecialChar[0] = '<EFBFBD>';
		  StrSpecialChar[1] = '\0';
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0xF1:  /* "%F1" --> "<22>" */
		  StrSpecialChar[0] = '<EFBFBD>';
		  StrSpecialChar[1] = '\0';
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               case 0xE7:  /* "%E7" --> "<22>" */
		  StrSpecialChar[0] = '<EFBFBD>';
		  StrSpecialChar[1] = '\0';
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
               default: /* The rest of special chars are stored as special code */
                  snprintf (StrSpecialChar,sizeof (StrSpecialChar),
                            (SpecialChar < 256 &&
                             (ChangeTo == Str_TO_TEXT ||
                              ChangeTo == Str_TO_MARKDOWN)) ? "%c" :
                        	                              "&#%u;",
                	    SpecialChar);
                  NumPrintableCharsFromReturn++;
                  ThereIsSpaceChar = false;
                  break;
              }
            /* Compute length of destination special char */
            LengthSpecStrDst = strlen (StrSpecialChar);

            /* Check new length of destination string after the copy */
            if (LengthStrDst + LengthSpecStrDst > MaxLengthStr)
               Err_ShowErrorAndExit ("Space allocated to string is full.");

            /* Copy to appropiate place the special character string */
            // strncpy (PtrDst,StrSpecialChar,LengthSpecStrDst);
            strcpy (PtrDst,StrSpecialChar);

            /* Increment pointer to character after ';' */
            PtrSrc += LengthSpecStrSrc;
            PtrDst += LengthSpecStrDst;

            /* Increment length of destination string */
            LengthStrDst += LengthSpecStrDst;
           }
         else	// Not a special char ==> copy char from source to destination
           {
            /* Check new length of destination string after the copy */
            if (LengthStrDst >= MaxLengthStr)
               Err_ShowErrorAndExit ("Space allocated to string is full.");

            /* Copy char from source to destination and increment pointers */
            *PtrDst++ = *PtrSrc++;

            /* Increment length of destination string */
            LengthStrDst++;
           }
        }
      StrDst[LengthStrDst] = '\0';

      /***** Copy destination string with changes to source string *****/
      strncpy (Str,StrDst,LengthStrDst);	// Str <-- StrDst
      Str[LengthStrDst] = '\0';

      /***** Free memory used for the destination string *****/
      free (StrDst);
     }

   if (RemoveLeadingAndTrailingSpaces == Str_REMOVE_SPACES)
     {
      /***** Remove leading spaces *****/
      Str_RemoveLeadingSpacesHTML (Str);

      /***** Remove trailing spaces *****/
      Str_RemoveTrailingSpacesHTML (Str);
     }
  }

/*****************************************************************************/
/****************** Remove the spaces iniciales of a string ******************/
/*****************************************************************************/

void Str_RemoveLeadingSpacesHTML (char *Str)
  {
   char *Ptr;

   /***** Find the first character no space from left to right *****/
   for (Ptr = Str;
	*Ptr;
	Ptr++)
     {
      /* If it's space ==> continue in the loop */
      if (isspace ((int) *Ptr) ||
	  *Ptr == '\xA0')	// Unicode translation for &nbsp;
         continue;
      /* Check forward if it's a <br> or <br /> */
      if (*Ptr == '<')
        {
         Ptr++;
         if (tolower ((int) *Ptr) != 'b')
           {
            Ptr--;
            break;
           }
         if (!*Ptr)
            break;
         Ptr++;
         if (tolower ((int) *Ptr) != 'r')
           {
            Ptr -= 2;
            break;
           }
         if (!*Ptr)
            break;
         Ptr++;
         if (*Ptr == '>')
            continue;	// It's <br>
         if (*Ptr != ' ')
           {
            Ptr -= 3;
            break;
           }
         if (!*Ptr)
            break;
         Ptr++;
         if (*Ptr != '/')
           {
            Ptr -= 4;
            break;
           }
         if (!*Ptr)
            break;
         Ptr++;
         if (*Ptr != '>')
           {
            Ptr -= 5;
            break;
           }
         continue;	// It's <br />
        }
      /* Check forward if it's &nbsp; */
      if (*Ptr == '&')
        {
         Ptr++;
         if (tolower ((int) *Ptr) != 'n')
           {
            Ptr--;
            break;
           }
         if (!*Ptr)
            break;
         Ptr++;
         if (tolower ((int) *Ptr) != 'b')
           {
            Ptr -= 2;
            break;
           }
         if (!*Ptr)
            break;
         Ptr++;
         if (tolower ((int) *Ptr) != 's')
           {
            Ptr -= 3;
            break;
           }
         if (!*Ptr)
            break;
         Ptr++;
         if (tolower ((int) *Ptr) != 'p')
           {
            Ptr -= 4;
            break;
           }
         if (!*Ptr)
            break;
         Ptr++;
         if (*Ptr != ';')
           {
            Ptr -= 5;
            break;
           }
         /* It's &nbsp; */
         continue;
        }
      /* It's not space */
      break;
     }

   /***** Ptr is the first character no space *****/
   if (Ptr != Str)
     {
      /* Copy string pointed by Ptr to Str.
         Do not use strcpy because according to strcpy manual:
         "The source and destination strings should not overlap,
         as the behavior is undefined" */
      while (*Ptr)
         *Str++ = *Ptr++;
      *Str = '\0';
     }
  }

/*****************************************************************************/
/******************* Remove the trailing spaces of a string ******************/
/*****************************************************************************/

void Str_RemoveTrailingSpacesHTML (char *Str)
  {
   char *Ptr;

   /* Find the first not space character starting at the end */
   for (Ptr = Str + strlen (Str) - 1;
	Ptr >= Str;
	Ptr--)
     {
      /* If it's space ==> continue in the loop */
      if (isspace ((int) *Ptr) ||
	  *Ptr == '\xA0')	// Unicode translation for &nbsp;
         continue;
      /* Check backward if it's <br> or <br /> */
      if (*Ptr == '>')
        {
         if (Ptr == Str)
            break;
         Ptr--;
         if (*Ptr == '/')	// Possible <br />
           {
            if (Ptr == Str)
               break;
            Ptr--;
            if (*Ptr != ' ')
              {
               Ptr += 2;
               break;
              }
            if (Ptr == Str)
               break;
            Ptr--;
            if (tolower ((int) *Ptr) != 'r')
              {
               Ptr += 3;
               break;
              }
            if (Ptr == Str)
               break;
            Ptr--;
            if (tolower ((int) *Ptr) != 'b')
              {
               Ptr += 4;
               break;
              }
            if (Ptr == Str)
               break;
            Ptr--;
            if (*Ptr != '<')
              {
               Ptr += 5;
               break;
              }
            /* It's <br /> */
            continue;
           }
         else	// Possible <br>
           {
            if (tolower ((int) *Ptr) != 'r')
              {
               Ptr++;
               break;
              }
            if (Ptr == Str)
               break;
            Ptr--;
            if (tolower ((int) *Ptr) != 'b')
              {
               Ptr += 2;
               break;
              }
            if (Ptr == Str)
               break;
            Ptr--;
            if (*Ptr != '<')
              {
               Ptr += 3;
               break;
              }
            /* It's <br> */
            continue;
           }
        }
      /* Check backward if it's &nbsp; */
      if (*Ptr == ';')
        {
         if (Ptr == Str)
            break;
         Ptr--;
         if (tolower ((int) *Ptr) != 'p')
           {
            Ptr ++;
            break;
           }
         if (Ptr == Str)
            break;
         Ptr--;
         if (tolower ((int) *Ptr) != 's')
           {
            Ptr += 2;
            break;
           }
         if (Ptr == Str)
            break;
         Ptr--;
         if (tolower ((int) *Ptr) != 'b')
           {
            Ptr += 3;
            break;
           }
         if (Ptr == Str)
            break;
         Ptr--;
         if (tolower ((int) *Ptr) != 'n')
           {
            Ptr += 4;
            break;
           }
         if (Ptr == Str)
            break;
         Ptr--;
         if (*Ptr != '&')
           {
            Ptr += 5;
            break;
           }
         /* It's &nbsp; */
         continue;
        }
      /* It's not space */
      break;
     }

   *(Ptr + 1) = '\0';
  }

/*****************************************************************************/
/********* Remove the leading zeros ('0', not '\0') from a string ************/
/*****************************************************************************/

void Str_RemoveLeadingZeros (char *Str)
  {
   size_t NumLeadingZeros;

   if (Str)
      if (Str[0])
	{
	 NumLeadingZeros = strspn (Str,"0");
	 if (NumLeadingZeros)
	    // Do not use strcpy / memcpy because the strings overlap
	    memmove (Str,&Str[NumLeadingZeros],
		     strlen (Str) - NumLeadingZeros + 1);
	}
  }

/*****************************************************************************/
/***************** Delete @'s at the start of a string ***********************/
/*****************************************************************************/

#include "swad_database.h"

void Str_RemoveLeadingArrobas (char *Str)
  {
   size_t NumLeadingArr;

   if (Str)
      if (Str[0])
	{
	 NumLeadingArr = strspn (Str,"@");
	 if (NumLeadingArr)
	    // Do not use strcpy / memcpy because the strings overlap
	    memmove (Str,&Str[NumLeadingArr],
		     strlen (Str) - NumLeadingArr + 1);
	}
  }

/*****************************************************************************/
/*************** Find string in a HTML file skipping comments ****************/
/*****************************************************************************/
/*
Search (case insensitive) the string Str in HTML file FileSrc, skipping comments.
Returns true if found.
Returns false if not found.
*/

bool Str_FindStrInFile (FILE *FileSrc,const char *Str,Str_SkipHTMLComments_t SkipHTMLComments)
  {
   int i;
   int Length = strlen (Str);
   int Ch;
   long CurPos;

   for (;;)
     {
      /* Skip possible comments */
      if ((Ch = Str_ReadCharAndSkipComments (FileSrc,SkipHTMLComments)) == EOF)	// Set pointer to '<' if not comment, or to first character after comment if comment
	 return false;
      CurPos = ftell (FileSrc);

      if (Str_ConvertToLowerLetter ((char) Ch) == Str_ConvertToLowerLetter (Str[0]))  // First char found
	{
	 for (i = 1;
	      i < Length;
	      i++)
	   {
            /* Skip possible comments */
 	    if ((Ch = Str_ReadCharAndSkipComments (FileSrc,SkipHTMLComments)) == EOF)	// Set pointer to '<' if not comment, or to first character after comment if comment
	       return false;
	    if (Str_ConvertToLowerLetter ((char) Ch) != Str_ConvertToLowerLetter (Str[i]))
	       break;
	   }
	 if (i == Length) // Found!
	    return true;
         else	// Not found, continue on next character
            fseek (FileSrc,CurPos,SEEK_SET);
	}
     }

   return false;	// Not reached
  }

/*****************************************************************************/
/******************* Search a string in a file backward **********************/
/*****************************************************************************/

/* The file queda posicionado in:
   If found --> in the character anterior to the first of the string
   If no found --> to the principio of the file */

bool Str_FindStrInFileBack (FILE *FileSrc,const char *Str,Str_SkipHTMLComments_t SkipHTMLComments)
  {
   int i;
   int Length = strlen (Str);
   int Ch;
   int ChFinal;
   long CurPos;

   ChFinal = Str_ConvertToLowerLetter (Str[Length-1]);
   if (fseek (FileSrc,-1L,SEEK_CUR))	// Go to the previous character
      return false;
   for (;;)
     {
      if ((Ch = Str_ReadCharAndSkipCommentsBackward (FileSrc,SkipHTMLComments)) == EOF)	// Set pointer to '>' if not comment, or to character before start of comment if comment
         return false;
      CurPos = ftell (FileSrc);

      if (Str_ConvertToLowerLetter ((char) Ch) == (char) ChFinal)
	{
	 for (i = Length - 2;
	      i >= 0;
	      i--)
	   {
	    if (fseek (FileSrc,-2L,SEEK_CUR))
	       return false;
            if ((Ch = Str_ReadCharAndSkipCommentsBackward (FileSrc,SkipHTMLComments)) == EOF)	// Set pointer to '>' if not comment, or to character before start of comment if comment
               return false;
	    if (Str_ConvertToLowerLetter ((char) Ch) != Str_ConvertToLowerLetter (Str[i]))
	       break;
	   }
	 if (i<0)	// Found!
	   {
	    fseek (FileSrc,-1L,SEEK_CUR);	// Move to start of found string in FileSrc
	    return true;
	   }
         else	// Not found, continue on next character
            fseek (FileSrc,CurPos,SEEK_SET);
	}
      if (fseek (FileSrc,-2L,SEEK_CUR))	// Move to previous character
	 return false;
     }

   return false;	// Not reached
  }

/*****************************************************************************/
/************* Search a string in a file writing in FileTgt ******************/
/*****************************************************************************/
/*
Search in the file FileSrc the string Str without distinguish uppercase from
lowercase. Write in FileTgt what is read from the file FileSrc.
*/

bool Str_WriteUntilStrFoundInFileIncludingStr (FILE *FileTgt,FILE *FileSrc,const char *Str,Str_SkipHTMLComments_t SkipHTMLComments)
  {
   int i;
   int StrLength = strlen (Str);
   int Ch;
   long CurPos1,CurPos2;

   for (;;)
     {
      /* Skip possible comments */
      if ((Ch = Str_ReadCharAndSkipCommentsWriting (FileSrc,FileTgt,SkipHTMLComments)) == EOF)	// Set pointer to '<' if not comment, or to first character after comment if comment
	 return false;
      CurPos1 = ftell (FileSrc);
      fputc (Ch,FileTgt);

      if (Str_ConvertToLowerLetter ((char) Ch) == Str_ConvertToLowerLetter (Str[0]))  // Found first character
	{
	 for (i = 1;
	      i < StrLength;
	      i++)
	   {
            /* Skip possible comments */
            if ((Ch = Str_ReadCharAndSkipComments (FileSrc,SkipHTMLComments)) == EOF)	// Set pointer to '<' if not comment, or to first character after comment if comment
	       return false;
	    if (Str_ConvertToLowerLetter ((char) Ch) != Str_ConvertToLowerLetter (Str[i]))
	       break;
	   }
	 if (i == StrLength) // Found!
           {
            CurPos2 = ftell (FileSrc);
            fseek (FileSrc,CurPos1,SEEK_SET);
	    while (ftell (FileSrc) < CurPos2)
	      {
	       Ch = fgetc (FileSrc);
               fputc (Ch,FileTgt);
	      }
	    return true;
           }
	 else	// Not found, continue on next character
            fseek (FileSrc,CurPos1,SEEK_SET);
	}
     }

   return false;	// Not reached
  }

/*****************************************************************************/
/*********************** Skip HTML comments in FileSrc ***********************/
/*****************************************************************************/
// Set pointer to '<' if not comment, or to first character after comment if comment
// Returns last char read after comments

static int Str_ReadCharAndSkipComments (FILE *FileSrc,Str_SkipHTMLComments_t SkipHTMLComments)
  {
   int Ch;
   char StrAux[1 + 1];  /* To check "!--" string */

   Ch = fgetc (FileSrc);

   if (SkipHTMLComments)
      while (Ch == (int) '<')
        {
         /***** Check if "<!--" *****/
         if (strcasecmp (Str_GetNextStrFromFileConvertingToLower (FileSrc,StrAux,1),"!"))
           {
            Str_FindStrInFileBack (FileSrc,"<",Str_NO_SKIP_HTML_COMMENTS);	// Not a comment. Return to start of directive
            return fgetc (FileSrc);
           }
         if (strcasecmp (Str_GetNextStrFromFileConvertingToLower (FileSrc,StrAux,1),"-"))
           {
            Str_FindStrInFileBack (FileSrc,"<",Str_NO_SKIP_HTML_COMMENTS);	// Not a comment. Return to start of directive
            return fgetc (FileSrc);
           }
         if (strcasecmp (Str_GetNextStrFromFileConvertingToLower (FileSrc,StrAux,1),"-"))
           {
            Str_FindStrInFileBack (FileSrc,"<",Str_NO_SKIP_HTML_COMMENTS);	// Not a comment. Return to start of directive
            return fgetc (FileSrc);
           }

         /***** It's a comment ==> skip comment *****/
         Str_FindStrInFile (FileSrc,"-->",Str_NO_SKIP_HTML_COMMENTS);

         /***** Get next character *****/
         Ch = fgetc (FileSrc);
        }

   return Ch;
  }

/*****************************************************************************/
/************* Skip HTML comments in FileSrc writing into FileTgt ************/
/*****************************************************************************/
// Set pointer to '<' if not comment, or to first character after comment if comment
// Returns last char read after comments

static int Str_ReadCharAndSkipCommentsWriting (FILE *FileSrc,FILE *FileTgt,Str_SkipHTMLComments_t SkipHTMLComments)
  {
   int Ch;
   char StrAux[1 + 1];  /* To check "!--" string */

   Ch = fgetc (FileSrc);

   if (SkipHTMLComments)
      while (Ch == (int) '<')
        {
         /***** Check if "<!--" *****/
         if (strcasecmp (Str_GetNextStrFromFileConvertingToLower (FileSrc,StrAux,1),"!"))
           {
            Str_FindStrInFileBack (FileSrc,"<",Str_NO_SKIP_HTML_COMMENTS);	// Not a comment. Return to start of directive
            return fgetc (FileSrc);
           }
         if (strcasecmp (Str_GetNextStrFromFileConvertingToLower (FileSrc,StrAux,1),"-"))
           {
            Str_FindStrInFileBack (FileSrc,"<",Str_NO_SKIP_HTML_COMMENTS);	// Not a comment. Return to start of directive
            return fgetc (FileSrc);
           }
         if (strcasecmp (Str_GetNextStrFromFileConvertingToLower (FileSrc,StrAux,1),"-"))
           {
            Str_FindStrInFileBack (FileSrc,"<",Str_NO_SKIP_HTML_COMMENTS);	// Not a comment. Return to start of directive
            return fgetc (FileSrc);
           }

         /***** It's a comment ==> skip comment *****/
         Str_FindStrInFileBack (FileSrc,"<",Str_NO_SKIP_HTML_COMMENTS);	// Return to start of comment
         Str_WriteUntilStrFoundInFileIncludingStr (FileTgt,FileSrc,"-->",Str_NO_SKIP_HTML_COMMENTS);	// Skip comment in search, and write it to FileTgt

         /***** Get next character *****/
         Ch = fgetc (FileSrc);
        }

   return Ch;
  }

/*****************************************************************************/
/******************************* Skip a comment ******************************/
/*****************************************************************************/
// Set pointer to '>' if not comment, or to character previous to start of comment if comment
// Returns char preceeding comments, of EOF if start of file reached

static int Str_ReadCharAndSkipCommentsBackward (FILE *FileSrc,Str_SkipHTMLComments_t SkipHTMLComments)
  {
   int Ch;
   char StrAux[3 + 1];  /* To check "--" string */

   Ch = fgetc (FileSrc);

   if (SkipHTMLComments)
      while (Ch == (int) '>')
        {
         /* Check if "-->" */
         // Now: "<!--example of comment-->..."
         //                                ^
         if (fseek (FileSrc,-3L,SEEK_CUR))	// Go to start of possible "-->" */
            return EOF;

         // Now: "<!--example of comment-->..."
         //                             ^
         if (strcasecmp (Str_GetNextStrFromFileConvertingToLower (FileSrc,StrAux,3),"-->"))	// Not a comment
            return '>';

         /***** It's a comment end *****/
         Str_FindStrInFileBack (FileSrc,"<!--",Str_NO_SKIP_HTML_COMMENTS);	// Skip comment backwards
         if (fseek (FileSrc,-1L,SEEK_CUR))		// Return to character previous to '<'
            return EOF;

         /***** Get character previous to '<' *****/
         Ch = fgetc (FileSrc);
        }

   return Ch;
  }

/*****************************************************************************/
/****** Scan next string in file FileSrc until find </td>              *******/
/****** ( skipping comments <!--...--> and directives <...> )          *******/
/****** and write string into Str (MaxLength characters as much)       *******/
/*****************************************************************************/

char *Str_GetCellFromHTMLTableSkipComments (FILE *FileSrc,char *Str,int MaxLength)
  {
   long CurPos;
   long PosNextTR;
   long PosTD;
   int i = 0;
   int Ch;
   bool EndCellFound = false;
   bool DirectiveFound;
   bool SpaceFound;
   char StrAux[1 + 1];  // To find next "/td>" or "nbsp;"

   Str[0] = '\0';

   /***** Find next <td ...> inside current row (before next <tr) *****/
   CurPos = ftell (FileSrc);

   Str_FindStrInFile (FileSrc,"<tr",Str_NO_SKIP_HTML_COMMENTS);
   PosNextTR = ftell (FileSrc) - 3;

   fseek (FileSrc,CurPos,SEEK_SET);
   Str_FindStrInFile (FileSrc,"<td",Str_NO_SKIP_HTML_COMMENTS);
   PosTD = ftell (FileSrc);

   if (PosTD > PosNextTR)
     {
      // <td not found in this row ==> leave current position unchanged
      fseek (FileSrc,CurPos,SEEK_SET);
      return Str;
     }

   Str_FindStrInFile (FileSrc,">",Str_NO_SKIP_HTML_COMMENTS);

   for (EndCellFound = false;
	!EndCellFound;
	)
     {
      if ((Ch = Str_ReadCharAndSkipComments (FileSrc,Str_SKIP_HTML_COMMENTS)) == EOF)	// Set pointer to '<' if not comment, or to first character after comment if comment
	 break;

      /***** Skip directives except </td> *****/
      DirectiveFound = (Ch == (int) '<');

      if (DirectiveFound)		// Start of directive, not a comment
	{
	 /* Check if it's </td> */
	 if (!strcasecmp (Str_GetNextStrFromFileConvertingToLower (FileSrc,StrAux,1),"/"))		// It's </
	    if (!strcasecmp (Str_GetNextStrFromFileConvertingToLower (FileSrc,StrAux,1),"t"))		// It's </t
	       if (!strcasecmp (Str_GetNextStrFromFileConvertingToLower (FileSrc,StrAux,1),"d"))	// It's </td
		  if (!strcasecmp (Str_GetNextStrFromFileConvertingToLower (FileSrc,StrAux,1),">"))	// It's </td>
	             EndCellFound = true;	// </td> found

	 if (!EndCellFound)
	   {
	    /* Skip directive */
	    Str_FindStrInFileBack (FileSrc,"<",Str_NO_SKIP_HTML_COMMENTS);
	    Str_FindStrInFile (FileSrc,">",Str_NO_SKIP_HTML_COMMENTS);
	   }
	}

      if (!EndCellFound)
	{
	 if (DirectiveFound)
	    Ch = (int) ' ';	// Replace directive for ' ' (separator)
	 else
	   {
	    /***** Check for space or &nbsp; *****/
	    SpaceFound = false;

	    if (Ch == (int) '&')
	      {
	       /* Check for &nbsp; (case insensitive) */
	       if (strcasecmp (Str_GetNextStrFromFileConvertingToLower (FileSrc,StrAux,1),"n"))
		 {	// It's not &n
		  Str_FindStrInFileBack (FileSrc,"&",Str_NO_SKIP_HTML_COMMENTS);	// Back until &
		  Str_FindStrInFile (FileSrc,"&",Str_NO_SKIP_HTML_COMMENTS);		// Skip &
		 }
	       else if (strcasecmp (Str_GetNextStrFromFileConvertingToLower (FileSrc,StrAux,1),"b"))
		 {	// It's not &nb
		  Str_FindStrInFileBack (FileSrc,"&",Str_NO_SKIP_HTML_COMMENTS);	// Back until &
		  Str_FindStrInFile (FileSrc,"&",Str_NO_SKIP_HTML_COMMENTS);		// Skip &
		 }
	       else if (strcasecmp (Str_GetNextStrFromFileConvertingToLower (FileSrc,StrAux,1),"s"))
		 {	// It's not &nbs
		  Str_FindStrInFileBack (FileSrc,"&",Str_NO_SKIP_HTML_COMMENTS);	// Back until &
		  Str_FindStrInFile (FileSrc,"&",Str_NO_SKIP_HTML_COMMENTS);		// Skip &
		 }
	       else if (strcasecmp (Str_GetNextStrFromFileConvertingToLower (FileSrc,StrAux,1),"p"))
		 {	// It's not &nbsp
		  Str_FindStrInFileBack (FileSrc,"&",Str_NO_SKIP_HTML_COMMENTS);	// Back until &
		  Str_FindStrInFile (FileSrc,"&",Str_NO_SKIP_HTML_COMMENTS);		// Skip &
		 }
	       else if (strcasecmp (Str_GetNextStrFromFileConvertingToLower (FileSrc,StrAux,1),";"))
		 {	// It's not &nbsp;
		  Str_FindStrInFileBack (FileSrc,"&",Str_NO_SKIP_HTML_COMMENTS);	// Back until &
		  Str_FindStrInFile (FileSrc,"&",Str_NO_SKIP_HTML_COMMENTS);		// Skip &
		 }
	       else	// It's &nbsp;
		  SpaceFound = true;
	      }

	    /***** Skip spaces *****/
	    if (isspace (Ch) ||
		Ch == 0xC2   ||	// Used in Unicode &nbsp;	// TODO: Skip '\xA0' or the sequence "\xC2\xA0"
		Ch == 0xA0)	// Used in Unicode &nbsp;
		SpaceFound = true;

	    if (SpaceFound)
	       Ch = (int) ' ';	// Replace any kind of space for ' ' (separator)
	   }

	 if (i < MaxLength)
	    Str[i++] = (char) Ch;
	}
     }
   Str[i] = '\0';
   return Str;
  }

/*****************************************************************************/
/******************* Read the next N characters in a string ******************/
/*****************************************************************************/
/*
Read from the file FileSrc the next N characters converting them
to lowercase and store them in Str. Return a pointer to the string.
*/

char *Str_GetNextStrFromFileConvertingToLower (FILE *FileSrc,char *Str, int N)
  {
   int i,Ch;

   for (i = 0;
	i < N;
	i++)
     {
      if ((Ch = fgetc (FileSrc)) == EOF)
	 break;
      Str[i] = Str_ConvertToLowerLetter ((char) Ch);
     }
   Str[i] = '\0';
   return Str;
  }

/*****************************************************************************/
/********** Get from StrSrc into StrDst the next string until space **********/
/*****************************************************************************/
// Modifies *StrSrc

void Str_GetNextStringUntilSpace (const char **StrSrc,char *StrDst,size_t MaxLength)
  {
   size_t i = 0;
   int Ch;

   /***** Skip leading spaces *****/
   do
     {
      if ((Ch = (int) **StrSrc) != 0)
	 (*StrSrc)++;
     }
   while (isspace (Ch) ||
	  Ch == 0xC2   ||	// Used in Unicode &nbsp;	// TODO: Skip '\xA0' or the sequence "\xC2\xA0"
    	  Ch == 0xA0);		// Used in Unicode &nbsp;

   /***** Copy string while non-space characters *****/
   while (Ch &&
	  !(isspace (Ch) ||
	    Ch == 0xC2   ||	// Used in Unicode &nbsp;	// TODO: Skip '\xA0' or the sequence "\xC2\xA0"
    	    Ch == 0xA0))	// Used in Unicode &nbsp;
     {
      if (i < MaxLength)
	 StrDst[i++] = (char) Ch;
      if ((Ch = (int) **StrSrc) != 0)
	 (*StrSrc)++;
     }
   StrDst[i] = '\0';
  }

/*****************************************************************************/
/******* Get from StrSrc into StrDst the next string until separator *********/
/*****************************************************************************/
// Modifies *StrSrc

void Str_GetNextStringUntilSeparator (const char **StrSrc,char *StrDst,size_t MaxLength)
  {
   size_t i = 0;
   int Ch;

   /***** Skip separators *****/
   do
     {
      if ((Ch = (int) **StrSrc) != 0)
	 (*StrSrc)++;
     }
   while (isspace (Ch)    ||
	  Ch == 0xC2      ||	// Used in Unicode &nbsp;	// TODO: Skip '\xA0' or the sequence "\xC2\xA0"
    	  Ch == 0xA0      ||	// Used in Unicode &nbsp;
	  Ch == (int) ',' ||
	  Ch == (int) ';');

   /***** Copy string while no separator found *****/
   while (Ch &&
	  !(isspace (Ch)    ||
	    Ch == 0xC2      ||	// Used in Unicode &nbsp;	// TODO: Skip '\xA0' or the sequence "\xC2\xA0"
    	    Ch == 0xA0      ||	// Used in Unicode &nbsp;
	    Ch == (int) ',' ||
	    Ch == (int) ';'))
     {
      if (i < MaxLength)
	 StrDst[i++] = (char) Ch;
      if ((Ch = (int) **StrSrc) != 0)
	 (*StrSrc)++;
     }
   StrDst[i] = '\0';
  }

/*****************************************************************************/
/********** Get from StrSrc into StrDst the next string until comma **********/
/*****************************************************************************/
// Modifies *StrSrc
// Leading spaces are not copied
// Trailing spaces are removed at end

void Str_GetNextStringUntilComma (const char **StrSrc,char *StrDst,size_t MaxLength)
  {
   int Ch;
   char *Ptr;
   size_t i = 0;

   /***** Skip leading spaces and ',' *****/
   Ch = (int) **StrSrc;
   while (isspace (Ch) ||
	  Ch == 0xC2   ||	// Used in Unicode &nbsp;	// TODO: Skip '\xA0' or the sequence "\xC2\xA0"
    	  Ch == 0xA0   ||	// Used in Unicode &nbsp;
	  Ch == (int) ',')
     {
      (*StrSrc)++;
      Ch = (int) **StrSrc;
     }

   /***** Copy string until ',' or end *****/
   Ptr = StrDst;
   while (Ch && Ch != (int) ',')
     {
      if (i < MaxLength)
        {
	 *Ptr++ = (char) Ch;
         i++;
        }
      (*StrSrc)++;
      Ch = (int) **StrSrc;
     }

   /***** Remove trailing spaces *****/
   for (Ptr--;
	Ptr >= *StrSrc;
	Ptr--)
      if (!(isspace ((int) *Ptr) ||
	    *Ptr == '\xA0'))	// Unicode translation for &nbsp;
         break;
   *(Ptr + 1) = '\0';
  }

/*****************************************************************************/
/***************** Replace several spaces of a string for one ****************/
/*****************************************************************************/

void Str_ReplaceSeveralSpacesForOne (char *Str)
  {
   char *PtrSrc, *PtrDst;
   bool PreviousWasSpace = false;

   /***** Do the replacing *****/
   for (PtrDst = PtrSrc = Str;
	*PtrSrc;)
      if (isspace ((int) *PtrSrc) ||
	  *PtrSrc == '\xA0')	// Unicode translation for &nbsp;
        {
         if (!PreviousWasSpace)
            *PtrDst++ = ' ';
         PreviousWasSpace = true;
         PtrSrc++;
        }
      else
        {
         PreviousWasSpace = false;
         *PtrDst++ = *PtrSrc++;
        }
   *PtrDst = '\0';
  }

/*****************************************************************************/
/************* Copy a string to another changing ' ' to '%20' ****************/
/*****************************************************************************/

void Str_CopyStrChangingSpaces (const char *StringWithSpaces,char *StringWithoutSpaces,unsigned MaxLength)
  {
   const char *PtrSrc;
   char *PtrDst;
   unsigned Length = 0;

   for (PtrSrc = StringWithSpaces, PtrDst = StringWithoutSpaces;
	*PtrSrc && Length <= MaxLength;
        PtrSrc++)
      if (*PtrSrc == ' ')
        {
         Length += 3;
         if (Length <= MaxLength)
           {
            *PtrDst++ = '%';
            *PtrDst++ = '2';
            *PtrDst++ = '0';
           }
        }
      else
        {
         Length++;
         if (Length <= MaxLength)
            *PtrDst++ = *PtrSrc;
        }
   *PtrDst = '\0';

   if (Length > MaxLength)
      Err_ShowErrorAndExit ("Path is too long.");
  }

/*****************************************************************************/
/* Convert string with a code (of group type, group, degree, etc.) to long **/
/*****************************************************************************/
// Return -1L if code not found in Str

long Str_ConvertStrCodToLongCod (const char *Str)
  {
   long Code;

   if (!Str)
      return -1L;

   if (Str[0] == '\0')
      return -1L;

   if (sscanf (Str,"%ld",&Code) != 1)
      return -1L;

   return Code;
  }

/*****************************************************************************/
/******************* Get parameter with index of question ********************/
/*****************************************************************************/

unsigned Str_ConvertStrToUnsigned (const char *UnsignedStr)
  {
   long LongNum = Str_ConvertStrCodToLongCod (UnsignedStr);

   return (LongNum >= 0 &&
	   LongNum <= UINT_MAX) ? (unsigned) LongNum :
	                          0;
  }

/*****************************************************************************/
/**** Compute length of root (all except extension) of the name of a file ****/
/*****************************************************************************/

size_t Str_GetLengthRootFileName (const char *FileName)
  {
   char *PtrToDot = strrchr (FileName,(int) '.');
   size_t LengthFileName = strlen (FileName);

   if (PtrToDot)
      return LengthFileName - strlen (PtrToDot);
   else
      return LengthFileName;
  }

/*****************************************************************************/
/************** Get the name of a file from a complete path ******************/
/*****************************************************************************/
// Split a full path in path (without ending '/' ) and a file name

void Str_SplitFullPathIntoPathAndFileName (const char FullPath[PATH_MAX + 1],
                                           char PathWithoutFileName[PATH_MAX + 1],
                                           char FileName[NAME_MAX + 1])
  {
   const char *PtrFileName;
   size_t LengthUntilFileName;

   /***** Find the start of filename *****/
   if ((PtrFileName = strrchr (FullPath,(int) '/')) != NULL)
      PtrFileName++;
   else if ((PtrFileName = strrchr (FullPath,(int) '\\')) != NULL)
      PtrFileName++;
   else
      PtrFileName = FullPath;

   /***** Get PathWithoutFileName *****/
   LengthUntilFileName = (size_t) (PtrFileName - FullPath);	// Last slash included
   if (LengthUntilFileName > 1)
     {
      Str_Copy (PathWithoutFileName,FullPath,PATH_MAX);
      PathWithoutFileName[LengthUntilFileName - 1] = '\0';	// Do not copy ending slash
     }
   else
      PathWithoutFileName[0] = '\0';

   /***** Get FileName *****/
   Str_Copy (FileName,PtrFileName,NAME_MAX);
  }

/*****************************************************************************/
/************** Check if the extension of a file is .Extension ***************/
/*****************************************************************************/
// Return true if FileName ends by .Extension
// Else return false

bool Str_FileIs (const char *FileName,const char *Extension)
  {
   int i;
   int j;
   size_t LengthExtension = strlen (Extension);

   /***** Check length of extension. Extension valid are, for example "zip", "html", "mhtml" *****/
   if (LengthExtension < Fil_MIN_BYTES_FILE_EXTENSION ||
       LengthExtension > Fil_MAX_BYTES_FILE_EXTENSION)
      return false;

   /***** Check the extension *****/
   for (i = strlen (FileName) - 1, j = LengthExtension - 1;
	i > 0 && j >= 0;
	i--, j--)
      if (Str_ConvertToLowerLetter (FileName[i]) != Str_ConvertToLowerLetter (Extension[j]))
	 return false;

   if (j >= 0)	/* If all the characters of the extension have not been checked
		   due to the name of the file is too short */
      return false;

   /***** Check the dot before the extension *****/
   return (FileName[i] == '.');
  }

/*****************************************************************************/
/**************** Check if the extension of a file is .html ******************/
/*****************************************************************************/
// Return true if FileName ends by .htm or .html
// Else return false

bool Str_FileIsHTML (const char *FileName)
  {
   if (Str_FileIs (FileName,"htm"))
      return true;
   return Str_FileIs (FileName,"html");
  }

/*****************************************************************************/
/********************* Check if Path1 starts by Path2 ************************/
/*****************************************************************************/

bool Str_Path1BeginsByPath2 (const char *Path1,const char *Path2)
  {
   /* The string Path1 must start by the complete string Path2 */
   while (*Path2)
      if (*Path2++ != *Path1++)
         return false;

   /* The string Path1 starts by the complete string Path2 */
   /* Check that the next character of Path1 is '\0' or '/' */
   return *Path1 == '\0' || *Path1 == '/';
  }

/*****************************************************************************/
/** Skip spaces in a file seeking it before of reading the first non-blank ***/
/*****************************************************************************/

void Str_SkipSpacesInFile (FILE *FileSrc)
  {
   int Ch;

   while ((Ch = fgetc (FileSrc)) != EOF)
      if (!(isspace (Ch) ||
	    Ch == 0xC2   ||	// Used in Unicode &nbsp;	// TODO: Skip '\xA0' or the sequence "\xC2\xA0"
    	    Ch == 0xA0))	// Used in Unicode &nbsp;
	{
	 fseek (FileSrc,-1L,SEEK_CUR);
	 break;
	}
  }

/*****************************************************************************/
/***************** Write a string to a file changing *************************/
/***************** <br> or <br /> for return         *************************/
/***************** and &nbsp; for space              *************************/
/*****************************************************************************/

void Str_FilePrintStrChangingBRToRetAndNBSPToSpace (FILE *FileTgt,const char *Str)
  {
   while (*Str)
     {
      /* Is &nbsp;? */
      if (*Str == '&')
        {
         if (*(Str + 1) == 'N' || *(Str + 1) == 'n')
            if (*(Str + 2) == 'B' || *(Str + 2) == 'b')
               if (*(Str + 3) == 'S' || *(Str + 3) == 's')
                  if (*(Str + 4) == 'P' || *(Str + 4) == 'p')
                     if (*(Str + 5) == ';')
                       {
                        fputc ((int) ' ',FileTgt);
                        Str += 6;
                        continue;
                       }
        }
      /* Is <br> or <br />? */
      else if (*Str == '<')
        {
         if (*(Str + 1) == 'B' || *(Str + 1) == 'b')
            if (*(Str + 2) == 'R' || *(Str + 2) == 'r')
              {
               if (*(Str + 3) == '>')
                 {
                  fputc ((int) '\n',FileTgt);
                  Str += 4;
                  continue;
                 }
               else if (*(Str + 3) == ' ')
                 {
                  if (*(Str + 4) == '/')
                     if (*(Str + 5) == '>')
                       {
                        fputc ((int) '\n',FileTgt);
                        Str += 6;
                        continue;
                       }
                 }
              }
        }

      fputc ((int) *Str,FileTgt);
      Str++;
     }
  }

/*****************************************************************************/
/*************** Search a string in a file and/or in a string ****************/
/*****************************************************************************/
/*
Search in the file FileSrc the string StrDelimit.
Write in the file FileTgt and/or StrDst the characters read from FileSrc, not including StrDelimit!.
StrDst can be NULL if you don't want to use them.
If StrDelimit is found, return 1.
If what is read exceed MaxLength, abort and return 0.
If StrDelimit is not found, return -1.
*/

#define Str_MAX_BYTES_BOUNDARY_STR 100

int Str_ReadFileUntilBoundaryStr (FILE *FileSrc,char *StrDst,
                                  const char *BoundaryStr,
                                  unsigned LengthBoundaryStr,
                                  unsigned long long MaxLength)
  {
   unsigned NumBytesIdentical;			// Number of characters identical in each iteration of the loop
   unsigned NumBytesReadButNotDiscarded;	// Number of characters read from the source file...
						// ...and not fully discarded in search
   int Buffer[Str_MAX_BYTES_BOUNDARY_STR + 1];
   unsigned StartIndex;
   unsigned i;
   char *Ptr; // Pointer used to go through StrDst writing characters
   unsigned long long DstLength;

   /***** Checkings on boundary string *****/
   if (!LengthBoundaryStr)
     {
      if (StrDst != NULL)
	 *StrDst = '\0';
      return 1;
     }
   if (LengthBoundaryStr > Str_MAX_BYTES_BOUNDARY_STR)
      Err_ShowErrorAndExit ("Delimiter string too large.");
   Ptr = StrDst;

   StartIndex = 0;
   NumBytesReadButNotDiscarded = 0;
   DstLength = 0;

   for (;;)
     {
      if (!NumBytesReadButNotDiscarded)
	{      // Read next character
	 Buffer[StartIndex] = fgetc (FileSrc);
	 if (feof (FileSrc))
	   {
	    if (StrDst != NULL)
	       *Ptr = '\0';
	    return -1;
	   }
	 NumBytesReadButNotDiscarded++;
	}

      if (Buffer[StartIndex] == (int) BoundaryStr[0]) // First character identical
	{
	 for (NumBytesIdentical = 1, i = (StartIndex + 1) % LengthBoundaryStr;
	      NumBytesIdentical < LengthBoundaryStr;
	      NumBytesIdentical++, i = (i + 1) % LengthBoundaryStr)
	   {
	    if (NumBytesReadButNotDiscarded == NumBytesIdentical) // Last character is identical
	      {
	       Buffer[i] = fgetc (FileSrc);  // Read next character
	       if (feof (FileSrc))
		 {
		  if (StrDst != NULL)
		     *Ptr = '\0';
		  return -1;
		 }
	       NumBytesReadButNotDiscarded++;
	      }
	    if (Buffer[i] != (int) BoundaryStr[NumBytesIdentical])  // Next character is different
	       break;
	   }
	 if (NumBytesIdentical == LengthBoundaryStr) // Boundary found
	   {
	    if (StrDst != NULL)
	       *Ptr = '\0';
	    return 1;
	   }
	}

      if (DstLength == MaxLength)
	{
	 if (StrDst != NULL)
	    *Ptr = '\0';
	 return 0;
	}

      if (StrDst != NULL)
	 *Ptr++ = (char) Buffer[StartIndex];

      StartIndex = (StartIndex + 1) % LengthBoundaryStr;
      NumBytesReadButNotDiscarded--;
      DstLength++;
     }

   return 0;	// Not reached
  }

/*****************************************************************************/
/****** Convert invalid characters in a file name to valid characters ********/
/*****************************************************************************/
// Return true if the name of the file o folder is valid
// If the name is not valid, an alert will contain feedback text
// File names with heading and trailing spaces are allowed

bool Str_ConvertFilFolLnkNameToValid (char *FileName)
  {
   extern const char *Txt_UPLOAD_FILE_X_invalid_name_NO_HTML;
   extern const char *Txt_UPLOAD_FILE_X_invalid_name;
   extern const char *Txt_UPLOAD_FILE_Invalid_name_NO_HTML;
   extern const char *Txt_UPLOAD_FILE_Invalid_name;
   char *Ptr;
   unsigned NumAlfanum = 0;
   unsigned NumSpaces  = 0;
   unsigned NumPoints  = 0;
   bool FileNameIsOK = false;

   Ptr = FileName;
   if (*Ptr)	// FileName is not empty
     {
      for (;
	   *Ptr;
	   Ptr++)
	{
	 if (*Ptr == ' ')
	   {
	    NumPoints = 0;
	    if (++NumSpaces > 1)
	      {
	       *Ptr = '_';
	       NumAlfanum++;
	       NumSpaces = NumPoints = 0;
	      }
	   }
	 else if (*Ptr == '.')
	   {
	    if (++NumPoints > 1)	// Don't allow ".."
	      {
	       *Ptr = '_';
	       NumAlfanum++;
	       NumSpaces = NumPoints = 0;
	      }
	   }
	 else
	   {
	    switch (*Ptr)
	      {
	       case '<EFBFBD>': *Ptr = 'a'; break;
	       case '<EFBFBD>': *Ptr = 'e'; break;
	       case '<EFBFBD>': *Ptr = 'i'; break;
	       case '<EFBFBD>': *Ptr = 'o'; break;
	       case '<EFBFBD>': *Ptr = 'u'; break;
	       case '<EFBFBD>': *Ptr = 'n'; break;
	       case '<EFBFBD>': *Ptr = 'a'; break;
	       case '<EFBFBD>': *Ptr = 'e'; break;
	       case '<EFBFBD>': *Ptr = 'i'; break;
	       case '<EFBFBD>': *Ptr = 'o'; break;
	       case '<EFBFBD>': *Ptr = 'u'; break;
	       case '<EFBFBD>': *Ptr = 'c'; break;

	       case '<EFBFBD>': *Ptr = 'A'; break;
	       case '<EFBFBD>': *Ptr = 'E'; break;
	       case '<EFBFBD>': *Ptr = 'I'; break;
	       case '<EFBFBD>': *Ptr = 'O'; break;
	       case '<EFBFBD>': *Ptr = 'U'; break;
	       case '<EFBFBD>': *Ptr = 'N'; break;
	       case '<EFBFBD>': *Ptr = 'A'; break;
	       case '<EFBFBD>': *Ptr = 'E'; break;
	       case '<EFBFBD>': *Ptr = 'I'; break;
	       case '<EFBFBD>': *Ptr = 'O'; break;
	       case '<EFBFBD>': *Ptr = 'U'; break;
	       case '<EFBFBD>': *Ptr = 'C'; break;
	      }
	    if ((*Ptr >= 'a' && *Ptr <= 'z') ||
		(*Ptr >= 'A' && *Ptr <= 'Z') ||
		(*Ptr >= '0' && *Ptr <= '9') ||
		 *Ptr == '_' ||
		 *Ptr == '-')
	      {
	       NumAlfanum++;
	       NumSpaces = NumPoints = 0;
	      }
	    else
	      {
	       *Ptr = '_';
	       NumAlfanum++;
	       NumSpaces = NumPoints = 0;
	      }
	   }
	}
      if (NumAlfanum)
         FileNameIsOK = true;
      else
	 Ale_CreateAlert (Ale_WARNING,NULL,
			  Gbl.FileBrowser.UploadingWithDropzone ? Txt_UPLOAD_FILE_X_invalid_name_NO_HTML :
								  Txt_UPLOAD_FILE_X_invalid_name,
			  FileName);
     }
   else	// FileName is empty
      Ale_CreateAlert (Ale_WARNING,NULL,
		       Gbl.FileBrowser.UploadingWithDropzone ? Txt_UPLOAD_FILE_Invalid_name_NO_HTML :
							       Txt_UPLOAD_FILE_Invalid_name);

   return FileNameIsOK;
  }

/*****************************************************************************/
/************ Convert a string to a valid name of file or folder *************/
/*****************************************************************************/

void Str_ConvertToValidFileName (char *Str)
  {
   char *Ptr;

   for (Ptr = Str;
	*Ptr;
	Ptr++)
     {
      if ((*Ptr >= 'a' && *Ptr <= 'z') ||
	  (*Ptr >= 'A' && *Ptr <= 'Z') ||
	  (*Ptr >= '0' && *Ptr <= '9') ||
	  *Ptr == '_' ||
	  *Ptr == '-')
         continue;
      if (isspace ((int) *Ptr) ||
	  *Ptr == '\xA0')
	 *Ptr = '_';
      else
	 switch (*Ptr)
	   {
	    case '<EFBFBD>': case '<EFBFBD>': case '<EFBFBD>': case '<EFBFBD>': *Ptr = 'a'; break;
	    case '<EFBFBD>': case '<EFBFBD>': case '<EFBFBD>': case '<EFBFBD>': *Ptr = 'e'; break;
	    case '<EFBFBD>': case '<EFBFBD>': case '<EFBFBD>': case '<EFBFBD>': *Ptr = 'i'; break;
	    case '<EFBFBD>': case '<EFBFBD>': case '<EFBFBD>': case '<EFBFBD>': *Ptr = 'o'; break;
	    case '<EFBFBD>': case '<EFBFBD>': case '<EFBFBD>': case '<EFBFBD>': *Ptr = 'u'; break;
	    case '<EFBFBD>': *Ptr = 'n'; break;
	    case '<EFBFBD>': *Ptr = 'c'; break;

	    case '<EFBFBD>': case '<EFBFBD>': case '<EFBFBD>': case '<EFBFBD>': *Ptr = 'A'; break;
	    case '<EFBFBD>': case '<EFBFBD>': case '<EFBFBD>': case '<EFBFBD>': *Ptr = 'E'; break;
	    case '<EFBFBD>': case '<EFBFBD>': case '<EFBFBD>': case '<EFBFBD>': *Ptr = 'I'; break;
	    case '<EFBFBD>': case '<EFBFBD>': case '<EFBFBD>': case '<EFBFBD>': *Ptr = 'O'; break;
	    case '<EFBFBD>': case '<EFBFBD>': case '<EFBFBD>': case '<EFBFBD>': *Ptr = 'U'; break;
	    case '<EFBFBD>': *Ptr = 'N'; break;
	    case '<EFBFBD>': *Ptr = 'C'; break;

	    default: *Ptr = '-'; break;
	   }
     }
  }

/*****************************************************************************/
/******************* Create a random alphanumeric string *********************/
/*****************************************************************************/

#define NUM_ALPHANUM_CHARS (10 + 26 + 26)

void Str_CreateRandomAlphanumStr (char *Str,size_t Length)
  {
   static const char CharTable[NUM_ALPHANUM_CHARS] =
     {'0','1','2','3','4','5','6','7','8','9',
      'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
      'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'
     };
   size_t i;

   /***** Set random chars in string *****/
   for (i = 0;
	i <Length;
	i++)
      Str[i] = CharTable[(unsigned) (((double) rand () * (double) (NUM_ALPHANUM_CHARS-1)) /
	                              (double) RAND_MAX + 0.5)];
   Str[Length] = '\0';
  }

/*****************************************************************************/
/****************************** Safe string copy *****************************/
/*****************************************************************************/
// DstSize does not include the ending byte '\0'

void Str_Copy (char *Dst,const char *Src,size_t DstSize)
  {
   char ErrorTxt[128];
   size_t SrcLength = strlen (Src);

   /***** Check if buffer has enough space for source *****/
   if (SrcLength > DstSize)
     {
      snprintf (ErrorTxt,sizeof (ErrorTxt),
	        "Trying to copy %zu chars into a %zu-chars buffer.",
                SrcLength,DstSize);
      Err_ShowErrorAndExit (ErrorTxt);
     }

   /***** Copy source into destination *****/
   strcpy (Dst,Src);
  }

/*****************************************************************************/
/************************** Safe string concatenation ************************/
/*****************************************************************************/
// DstSize does not include ending byte '\0'

void Str_Concat (char *Dst,const char *Src,size_t DstSize)
  {
   size_t DstLength;
   size_t SrcLength;
   size_t FreeSpace;
   char ErrorTxt[256];

   /***** Check if buffer has already overflowed *****/
   DstLength = strlen (Dst);
   if (DstLength > DstSize)
     {
      snprintf (ErrorTxt,sizeof (ErrorTxt),"%lu-chars buffer has %lu chars!",
                DstSize,DstLength);
      Err_ShowErrorAndExit (ErrorTxt);
     }

   /***** Check if buffer has enough space for source *****/
   // DstSize >= DstLength ==> FreeSpace >= 0
   FreeSpace = DstSize - DstLength;
   SrcLength = strlen (Src);
   if (FreeSpace < SrcLength)
     {
      snprintf (ErrorTxt,sizeof (ErrorTxt),
	        "Trying to concatenate %zu chars to a %zu-chars buffer"
	        " with free space for only %zu chars!",
                SrcLength,DstSize,FreeSpace);
      Err_ShowErrorAndExit (ErrorTxt);
     }

   /***** Concatenate ******/
   strcat (Dst,Src);
  }

/*****************************************************************************/
/********************** Build a "Go to <where>" title ************************/
/*****************************************************************************/
// Where is a hierarchy member (country, institution, center, degree or course
// Str_FreeGoToTitle() must be called after calling this function

static char *Str_Title = NULL;

char *Str_BuildGoToTitle (const char *Where)
  {
   extern const char *Txt_Go_to_X;

   if (Str_Title != NULL)
      Err_ShowErrorAndExit ("Can not build go to title.");

   if (asprintf (&Str_Title,Txt_Go_to_X,Where) < 0)
      Err_NotEnoughMemoryExit ();

   return Str_Title;
  }

void Str_FreeGoToTitle (void)
  {
   free (Str_Title);
   Str_Title = NULL;
  }