//---------------------------------------------------------------------------
// DynaChar 0.98  
//---------------------------------------------------------------------------
// [internal project name: CharList v.3.01/15.12.2003]
//---------------------------------------------------------------------------
//
// File contents:
//
//         0. Project notes (revisions, authors) 
//         1. Technical summary (in Polish only)
//         2. Code of DynaChar library (THIS FILE IS COMPILABLE!)
//         3. A simple example of using DynaChar
//
//---------------------------------------------------------------------------
// CharList Project:
//
//  Project started by NITRO Tech (c) 2001
//  Taken over by Sligtly Mad Programming Team (c) 2003
//  Created by Konrad "Groch" Grochowski <konrad_grochowski@op.pl>
//  on 12.12.2001
//  Last upgraded 7.06.2002 (project shut down)
//  Project reactivated 4.07.2003
//  Upgraded 7.07.2003
//  More last upgrades at 26.07.2003
//  Upgraded within the operators and some global corrections by
//  Ryszard "Rysieq" Kostecki <rpkost@tempac.okwf.fuw.edu.pl> on 5.09.2003
//  Some more global corrections by Konrad "Groch" Grochowski on 15.10.2003
//  CharList Project finished on 31.10.2003
//  and re-revisited with final corrections by Ryszard "Rysieq" Kostecki
//  and published as DynaChar v. 0.98 on 15.12.2003
//---------------------------------------------------------------------------
//  latest version of file is avaible at http://www.rysieq.prv.pl
//---------------------------------------------------------------------------
//
//
//     This file can be developed and distributed under terms of 
//     GNU General Public License, version 1, 2 or newer (as you wish).
//
//
//---------------------------------------------------------------------------

/*_____________[BEGIN OF TECHNICAL SUMMARY SECTION]___________________


:[DYNACHAR]:_________:{another great Slightly Mad product}:


SPECYFIKACJA TECHNICZNA

 DynaChar jest nowoczesnym, w pelni dynamicznym i latwym w uzyciu narzedziem
 do obslugi ciagow znakowych. Dzieki zastosowaniu listy jako szkieletu projektu
 (kazdy element oprocz wartosci posiada wskaznik do nastepnego) udalo sie 
 uniknac ciaglego tworzenia jakichs pomocniczych tablic. To przyspiesza prace 
 programu i oszczedza pamiec. Postaralismy sie takze, aby DynaChar mogl byc 
 wymiennie uzywaby ze zwyklym char* lub char[]. Dodalismy oczywiscie kilka 
 nowych, uzytecznych funcji (cos na wzor windozowego AnsiString).

______[ 1. Uwagi wstepne ]________________________________________

 Ciag znakow przechowywany jest podobnie do char*, z ta roznica ze nie ma
 koncowego NULL (jest dodawany przy konwersji na char*). UWAGA! Wstawienie
 w dowolne miejsce (poza pierwszym) listy znaku NULL nie powinno spowodowac
 zadnych bledow, jednak efekt dzialania niektorych funkcji (np.: konwersji,
 wypisania na ekran itp) jest nie okreslony. Jesli DynaChar nie jest pusty,
 to pierwszy znak musi byc rozny od NULL. Wszystkie pozycje indeksowane sa
 od 0.

______[ 2. Konstruktory  ]_________________________________________

 a. String(char *)

     Przeksztalca ciag znakow char na String. Dlugosc otrzymanej listy jest
     rowna ilosci znakow w ciagu, bez znaku NULL.

 b. String(double num, unsigned short precision = 6)

     Przeksztalca liczbe na String z dokladnoscia do precision-1 miejsc po
     przecinku. Notacja dziesietna "z kropka"

 c. String(&String)

     Konstruktor kopiujacy

______[ 3. Destruktor ]______________________________________________

    ~String()

______[ 4. Operatory  ]______________________________________________

 a. Rzutowania

     operator char *(); // Konwertuje String na ciag znakow + NULL

 b. Przeladowane

	char& operator[] (unsigned long num); 

		// Indeksowane od zera, w razie przekroczenia zakresu
                // zwracany jest ostatni znak w stringu oraz odpowiednia
                // informacja do cout. 	

	ostream& operator<< (ostream& s, String& a);
	istream& operator>> (istream& s, String& a);
	String& operator<< (String& a, istream &s);
	String& operator<< (String& a, const char * s);
	String& operator<< (String& a, const double &s);

	String& operator= (const String& source);
	String& operator= (char* source);
	String& operator+= (const String& source);
	String& operator+= (char* source);
	String& operator+= (char source);

	String operator+ (const String& ch1, const String& ch2);
	String operator+ (const String& ch1, char* ch2);
	String operator+ (const String& ch1, char ch2);

	unsigned short int operator== (const String& ch1, const String& ch2);
	unsigned short int operator== (const String& ch1, const char * ch2);

	unsigned short int operator<  (const String& ch1, const String& ch2);
	unsigned short int operator<  (const String& ch1, const char * ch2);
	unsigned short int operator>  (const String& ch1, const String& ch2);
	unsigned short int operator>  (const String& ch1, const char * ch2);
	unsigned short int operator<= (const String& ch1, const String& ch2);
	unsigned short int operator<= (const String& ch1, const char * ch2);
	unsigned short int operator>= (const String& ch1, const String& ch2);
	unsigned short int operator>= (const String& ch1, const char * ch2);

	unsigned short int operator!();


______[ 5. Inne funkcje skladowe ]_______________________________________

 a. long Length()

     zwraca dlugosc Stringu 

 b. long Count (char ch = '\n')

     zwraca ilosc wystapien znaku ch w ciagu

 c. String Split(long pos)

     rozdziela ciag na pozycji pos (rozna 0) i druga czesc zwraca, a w razie
     niepowodzenia NULL

 d. int Delete (long pos, long len)

     kasuje len znakow od pozycji pos, wartosc zwracana informuje o powodzeniu
     operacji

 e. int DeletePos(long pos1, long pos2)

     kasuje znaki od pos1 do pos2, wartosc zwracana informuje o powodzeniu
     operacji

 f. int Add (long pos, String * to_add)

     rozsuwa ciag na pozycji pos i wstawia to_add

 g. int Add (long pos, char* to_add)

     j.w.

 h. int Add (long pos, char to_add)

     j.w.

 i. void Clear()

     czysci String

 j. int SetLength (long len)

     ustala dlugosc Stringu na len. Jesli krotsza od pierwotnej, kasuje
     nadwyzke i zwraca -1, w przeciwnym przypadku zwraca 1. Kiedy operacja
     nieudana zwraca 0.

 k. int IsEmpty()

     zwraca 1 gdy string jest pusty, w przeciwnym razie 0.

 l. void tolower()

     zamienia wszystkie litery wielkie (A - Z) na male (a - z)

 m. void toupper()

     zamienia wszystkie litery male (a - z) na wielkie (A - Z)

 n. long Find (char c, long pos = 0)

     zwraca pozycje wystapienia c za pozycja pos

 o. void Reverse ()

     odwraca kolejnosc znakow w ciagu

 p. int TrimLeft ()

     usuwa biale znaki z lewej strony, zwraca ilosc usunietych znakow

 r. int TrimRight ()

     usuwa biale znaki z prawej strony, zwraca ilosc usunietych znakow

 s. int Trim() 

     usuwa biale znaki na krancach ciagu, zwraca ilosc usunietych znakow

 t. int Replace (char a, char b) 

     zastepuje znak a znakiem b, zwraca ilosc zastapionych znakow


_____________[END OF TECHNICAL SUMMARY SECTION]___________________*/
/*___________[BEGIN OF LIBRARY CODE SECTION]______________________*/


//---------------------------------------------------------------------------
// DynaChar 0.98  
//---------------------------------------------------------------------------
#ifndef CHARLIST
#define CHARLIST
//---------------------------------------------------------------------------
// Dear User!
// If you don't have any will to use strstream.h library, it's all right.
// Just uncomment the line at the bottom of this text.
// WARNING!
// You are going to do this on your own risk - without strstream.h
// conversions between double/float types and our dynamical strings
// can sometimes brake - it is still only EXPERIMENTAL property of
// our library. So - if it sounds sarcastic, don't take it seriously,
// and if it sounds dangerous, don't try it at home or at all...
//
//#define DONT_USE_OSTRSTREAM
//---------------------------------------------------------------------------
#include <iostream.h>
#ifndef DONT_USE_OSTRSTREAM
#include <strstream.h>
#include <iomanip.h>
#endif
//---------------------------------------------------------------------------
class CharListElem
{
 public:
	char value;
	CharListElem * to_next_pointer;
	CharListElem(char ch = NULL);
};
//---------------------------------------------------------------------------
class CharList
{
 private:
	CharListElem  * first;
 public:
	CharList (const char * str = NULL);
	CharList (double num, unsigned short precision=6);
	CharList (const CharList & source);
	CharList (const CharList * source);

	~CharList();

	long Length();
	int SetLength(long len);
	long Count (char ch = '\n');

	int Delete(long pos, long len=1);
	int DeletePos(long pos1, long pos2);

	int Add(long pos, char * to_add);
	int Add(long pos, CharList * to_add);
	int Add(long pos, const CharList& to_add);
	int Add(long pos, char to_add);

	int TrimLeft();
	int TrimRight();
	int Trim();

	long ToInt();
	double ToFloat();

	int Replace (char a, char b);

	void tolower();
	void toupper();

	void Clear();
	void Reverse();
	int IsEmpty();
	long Find(char c, long pos = 0);

	CharList Split (long pos);

	friend ostream& operator<< (ostream& s, CharList& a);
	friend istream& operator>> (istream& s, CharList& a);
	friend CharList& operator<< (CharList& a, istream &s);
	friend CharList& operator<< (CharList& a, const char * s);
	friend CharList& operator<< (CharList& a, const double &s);

	CharList& operator= (const CharList& source);
	CharList& operator= (char* source);
	CharList& operator+= (const CharList& source);
	CharList& operator+= (char* source);
	CharList& operator+= (char source);

	char& operator[] (unsigned long num);

	unsigned short int operator!();
	operator char *();

	friend CharList operator+ (const CharList& ch1, const CharList& ch2);
	friend CharList operator+ (const CharList& ch1, char* ch2);
	friend CharList operator+ (const CharList& ch1, char ch2);

	friend unsigned short int operator== (const CharList& ch1, const CharList& ch2);
	friend unsigned short int operator== (const CharList& ch1, const char * ch2);

	friend unsigned short int operator<  (const CharList& ch1, const CharList& ch2);
	friend unsigned short int operator<  (const CharList& ch1, const char * ch2);
	friend unsigned short int operator>  (const CharList& ch1, const CharList& ch2);
	friend unsigned short int operator>  (const CharList& ch1, const char * ch2);
	friend unsigned short int operator<= (const CharList& ch1, const CharList& ch2);
	friend unsigned short int operator<= (const CharList& ch1, const char * ch2);
	friend unsigned short int operator>= (const CharList& ch1, const CharList& ch2);
	friend unsigned short int operator>= (const CharList& ch1, const char * ch2);
};
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
typedef CharList DynaChar;
typedef CharList String;
//---------------------------------------------------------------------------
// Begin of implementation section... :)
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
CharListElem::CharListElem (char ch)
{
	value = ch;
	to_next_pointer = NULL;
}
//---------------------------------------------------------------------------
CharList::CharList (const char * str)
{
	CharListElem * pointer;
	pointer = first = new CharListElem (*str);
	while (*(++str))
	pointer = pointer->to_next_pointer = new CharListElem (*str);
}
//---------------------------------------------------------------------------
CharList::CharList (double num, unsigned short precision)
{
#ifndef DONT_USE_OSTRSTREAM
 ostrstream ostr;
 ostr<<setprecision(precision)<<num<<ends;
 char * str = ostr.str();
 CharListElem * pointer = first = new CharListElem (*str);
 while (*(++str))
 pointer = pointer->to_next_pointer = new CharListElem(*str);
#else
 CharListElem * pointer;
 CharListElem * tmpp;
 long tmpl;
 float tmpf;
 tmpl = (long)num;
 if (tmpl==0)
	 pointer = first = new CharListElem ('0');
 else if (tmpl < 0)
	 pointer = first = new CharListElem ('-');
 else if (tmpl)
 {
	 pointer = first = new CharListElem ('x');
	 while (tmpl)
	 {
		 tmpf = ((float)tmpl)/10;
		 tmpl = (long) tmpf;
		 tmpf -= tmpl;
		 tmpf *= 10;
		 pointer = pointer->to_next_pointer = new CharListElem (48 + (int)tmpf);
	 }
	 CharListElem * newfirst;
	 tmpp = first->to_next_pointer;
	 while (tmpp->to_next_pointer->to_next_pointer)
		tmpp = tmpp->to_next_pointer;
	 pointer = newfirst = tmpp->to_next_pointer;
	 tmpp->to_next_pointer = NULL;
	 while (tmpp->value != 'x')
		{
			tmpp = first;
			while (tmpp->to_next_pointer->to_next_pointer)
			 tmpp = tmpp->to_next_pointer;
			pointer = pointer->to_next_pointer = tmpp->to_next_pointer;
			tmpp->to_next_pointer = NULL;
		}
	 delete first;
	 first = newfirst;
 }
 tmpf = num - (long)num;
 if (tmpf)
 {
	 pointer = pointer->to_next_pointer = new CharListElem('.');
	 for (int i = 0; i < precision; i++)
		{
		 tmpf *= 10; //here this function losts precision
		 pointer = pointer->to_next_pointer = new CharListElem(48 + (int)tmpf);
		 tmpf -= (int)tmpf;
		}
 }
#endif
}
//---------------------------------------------------------------------------
CharList::CharList (const CharList & source)
{
 CharListElem * pointer1; //source
 CharListElem * pointer2; //copy
 pointer1 = source.first;
 pointer2 = first = new CharListElem (pointer1->value);
 while (pointer1 = pointer1->to_next_pointer)
	pointer2 = pointer2->to_next_pointer = new CharListElem(pointer1->value);
}
//---------------------------------------------------------------------------
CharList::CharList (const CharList * source)
{
 CharListElem * pointer1; //source
 CharListElem * pointer2; //copy
 pointer1 = source->first;
 pointer2 = first = new CharListElem (pointer1->value);
 while (pointer1 = pointer1->to_next_pointer)
 pointer2 = pointer2->to_next_pointer = new CharListElem(pointer1->value);
}
//---------------------------------------------------------------------------
CharList::~CharList()
{
 CharListElem * pointer1;
 CharListElem * pointer2;
 pointer1 = first;
 do
 {
	pointer2 = pointer1;
	pointer1 = pointer1->to_next_pointer;
	delete pointer2;
 }
 while(pointer1 != NULL);
 first=NULL;
}
//---------------------------------------------------------------------------
int CharList::Delete(long pos, long len)
{
 if (!len) return 1;
 long act_len = Length();
 if (len>act_len  || pos>act_len || pos+len>act_len) return 0;
 CharListElem * pointer1 = first;
 CharListElem * pointer2;
 long i;
 if (!pos)
 {
	for (i=0; i<len-1; i++)
	{
	 pointer2 = pointer1;
	 if(!(pointer1 = pointer1->to_next_pointer)) return 0;
	 delete pointer2;
	}
	if (pos+len==act_len)
	 first= new CharListElem(NULL);
	else
	{
	 pointer2 = pointer1;
	 if(!(pointer1 = pointer1->to_next_pointer)) return 0;
	 delete pointer2;
	 first=pointer1;
	}
 }
 else
 {
	CharListElem * pointer3;
	for (long act_pos=0; act_pos<(pos-1); act_pos++)
	 if (!(pointer1=pointer1->to_next_pointer)) return 0;
	pointer3 = pointer1;
	pointer1=pointer1->to_next_pointer;
	for (i=0; i<len-1; i++)
	{
	 pointer2 = pointer1;
	 if(!(pointer1 = pointer1->to_next_pointer)) return 0;
	 delete pointer2;
	}
	if (pos+len==act_len)
	 pointer3->to_next_pointer=NULL;
	else
	{
	 pointer2 = pointer1;
	 if(!(pointer1 = pointer1->to_next_pointer)) return 0;
	 delete pointer2;
	 pointer3->to_next_pointer = pointer1;
	}
 }
 return 1;
}
//---------------------------------------------------------------------------
int CharList::DeletePos(long pos1, long pos2)
{
 long len = pos2 - pos1;
 if (len<0) return 0;
 len++;
 return Delete (pos1,len);
}
//---------------------------------------------------------------------------
int CharList::Add(long pos, char * to_add)
{
 if (pos > Length()) return 0;
 CharListElem * pointer1 = first;
 CharListElem * pointer2;
 if (pos)
 {
	for (long act_pos=0; act_pos<(pos-1); act_pos++)
	 if (!(pointer1=pointer1->to_next_pointer)) return 0;
	pointer2 = pointer1->to_next_pointer;
 }
 else if ((!pos) && (*to_add))
 {
	pointer2 = first;
	pointer1 = first = new CharListElem (*(to_add++));
 }
 else return 0;
 while(*to_add)
	pointer1 = pointer1->to_next_pointer = new CharListElem(*(to_add++));
 pointer1->to_next_pointer=pointer2;
 return 1;
}
//---------------------------------------------------------------------------
int CharList::Add(long pos, char to_add)
{
 if (pos > Length()) return 0;
 CharListElem * pointer1 = first;
 CharListElem * pointer2;
 if (pos)
 {
	for (long act_pos=0; act_pos<(pos-1); act_pos++)
	 if (!(pointer1=pointer1->to_next_pointer)) return 0;
	pointer2 = pointer1->to_next_pointer;
	pointer1 = pointer1->to_next_pointer = new CharListElem(to_add);
 }
 else if (!pos && to_add)
 {
	pointer2 = first;
	pointer1 = first = new CharListElem (to_add);
 }
 else return 0;
 pointer1->to_next_pointer=pointer2;
 return 1;
}
//---------------------------------------------------------------------------
int CharList::Add(long pos, CharList * to_add)
{
 if (pos > Length()) return 0;
 CharListElem * pointer1 = first;         //this
 CharListElem * pointer2;                 //this helper
 CharListElem * pointer3 = to_add->first; //to_add
 if (pos)
 {
	for (long act_pos=0; act_pos<(pos-1); act_pos++)
	 if (!(pointer1=pointer1->to_next_pointer)) return 0;
	pointer2 = pointer1->to_next_pointer;
 }
 else if ((!pos) && (to_add->first->value))
 {
	pointer2 = first;
	pointer1 = first = new CharListElem (to_add->first->value);
	pointer3 = pointer3->to_next_pointer;
 }
 else return 0;
 while(pointer3)
 {
	pointer1 = pointer1->to_next_pointer = new CharListElem(pointer3->value);
	pointer3 = pointer3->to_next_pointer;
 }
 pointer1->to_next_pointer=pointer2;
 return 1;
}
//---------------------------------------------------------------------------
int CharList::Add(long pos, const CharList& to_add)
{
 if (pos > Length()) return 0;
 CharListElem * pointer1 = first;         //this
 CharListElem * pointer2;                 //this helper
 CharListElem * pointer3 = to_add.first;  //to_add
 if (pos)
 {
	for (long act_pos=0; act_pos<(pos-1); act_pos++)
	 if (!(pointer1=pointer1->to_next_pointer)) return 0;
	pointer2 = pointer1->to_next_pointer;
 }
 else if ((!pos) && (to_add.first->value))
 {
	pointer2 = first;
	pointer1 = first = new CharListElem (to_add.first->value);
	pointer3 = pointer3->to_next_pointer;
 }
 else return 0;
 while(pointer3)
 {
	pointer1 = pointer1->to_next_pointer = new CharListElem(pointer3->value);
	pointer3 = pointer3->to_next_pointer;
 }
 pointer1->to_next_pointer=pointer2;
 return 1;
}
//---------------------------------------------------------------------------
void CharList::Clear()
{
 this->~CharList();
 first=new CharListElem(NULL);
}
//---------------------------------------------------------------------------
long CharList::Length()
{
 CharListElem * pointer = first;
 if (!first->value)
	return 0;
 else
 {
	long len=1;
	while (pointer = pointer->to_next_pointer)
		len++;
	return len;
 }
}
//---------------------------------------------------------------------------
int CharList::SetLength(long len)
{
 long act_len = Length();
 if (len == act_len) return 0;
 else if (len>act_len)
 {
	CharListElem * pointer = first;
	long i;
	for (i=0; i<(act_len-1); i++)
	 pointer = pointer->to_next_pointer;
	for (i=0; i<(len-act_len); i++)
	 pointer = pointer->to_next_pointer = new CharListElem;
	return 1;
 }
 else if (len<act_len)
 {
	if(!DeletePos(len,act_len-1)) return 0;
	return -1;
 }
 return 0;
}
//---------------------------------------------------------------------------
long CharList::Count(char ch)
{
 CharListElem * pointer = first;
 long n = 0;
 if (first->value == ch)
	n=1;
 while (pointer = pointer->to_next_pointer)
	if (pointer->value == ch)
	 n++;
 return n;
}
//---------------------------------------------------------------------------
long CharList::Find(char c, long pos)
{
 CharListElem * pointer = first;
 long len = Length();
 if (pos>len) return -1;
 if (pos)
	for (long i=0; i<(pos+1); i++)
	 if (!(pointer = pointer->to_next_pointer)) return -1;
 while (1)
 {
	if (pointer->value == c) break;
	pointer = pointer->to_next_pointer;
	pos++;
	if (pos==len) return -1;
 }
 return pos;
}
//---------------------------------------------------------------------------
int CharList::IsEmpty()
{
 if (first->value==NULL)
	 return 1;
 else return 0;
}
//---------------------------------------------------------------------------
void CharList::tolower()
{
 CharListElem * pointer=first;
 while (pointer)
 {
	if (pointer->value>=65 && pointer->value<=90)
	 pointer->value += 32;
	pointer=pointer->to_next_pointer;
 }
}
//---------------------------------------------------------------------------
void CharList::toupper()
{
 CharListElem * pointer=first;
 while (pointer)
 {
	if (pointer->value>=97 && pointer->value<=122)
	 pointer->value -= 32;
	pointer=pointer->to_next_pointer;
 }
}
//---------------------------------------------------------------------------
void CharList::Reverse()
{
 CharListElem * newfirst;
 CharListElem * pointer;
 CharListElem * tmpp;
 if (tmpp = first->to_next_pointer)
	{
		while (tmpp->to_next_pointer->to_next_pointer)
		 tmpp = tmpp->to_next_pointer;
		pointer = newfirst = tmpp->to_next_pointer;
		tmpp->to_next_pointer = NULL;
		while (tmpp != first)
		 {
			 tmpp = first;
			 while (tmpp->to_next_pointer->to_next_pointer)
			 tmpp = tmpp->to_next_pointer;
			 pointer = pointer->to_next_pointer = tmpp->to_next_pointer;
			 tmpp->to_next_pointer = NULL;
		 }
		pointer->to_next_pointer = first;
		first = newfirst;
	}
 else; //nothing to Reverse
}
//---------------------------------------------------------------------------
CharList CharList::Split(long pos)
{
 CharList rest;
 CharListElem * pointer1 = first;
 CharListElem * pointer2;
 if (!pos || pos>Length()) return (char *)NULL;
 for (long i=0; i<(pos-1); i++)
	pointer1 = pointer1->to_next_pointer;
 pointer2 = pointer1->to_next_pointer;
 pointer1->to_next_pointer = NULL;
 rest.first = pointer2;
 return rest;
}
//---------------------------------------------------------------------------
int CharList::TrimLeft()
{
 if (first->value==NULL) return 0;
 int deld = 0;
 CharListElem * pointer = first;
 while (first->value >= 0 && first->value <=32)
 {
	if (!first->to_next_pointer)
	 {
		 first->value = NULL;
		 deld++;
		 return deld;
	 }
	first = first->to_next_pointer;
	delete pointer;
	pointer = first;
	deld++;
 }
 return deld;
}
//---------------------------------------------------------------------------
int CharList::TrimRight()
{
 if (first->value==NULL) return 0;
 int deld = 0;
 CharListElem * pointer = first;
 while (pointer->to_next_pointer->to_next_pointer)
	pointer = pointer->to_next_pointer;
 if (pointer==first)
 {
	if (first->to_next_pointer)
	 if (first->to_next_pointer->value >= 0 && first->to_next_pointer->value <= 32)
		{
			delete first->to_next_pointer;
			first->to_next_pointer = NULL;
			deld++;
		}
	if (first->value >= 0 && first->value <= 32 && !first->to_next_pointer)
	{
	 first->value = NULL;
	 deld++;
	}
	return deld;
 }
 while (pointer->to_next_pointer->value >= 0 && pointer->to_next_pointer->value <= 32)
 {
	delete pointer->to_next_pointer;
	deld++;
	pointer->to_next_pointer = NULL;
	pointer = first;
	while (pointer->to_next_pointer->to_next_pointer)
	 pointer = pointer->to_next_pointer;
	if (pointer==first)
	{
	 if (first->to_next_pointer)
		if (first->to_next_pointer->value >= 0 && first->to_next_pointer->value <= 32)
		 {
			 delete first->to_next_pointer;
			 first->to_next_pointer = NULL;
			 deld++;
		 }
	 if (first->value >= 0 && first->value <= 32 && !first->to_next_pointer)
	 {
		first->value = NULL;
		deld++;
	 }
	return deld;
	}
 }
 return deld;
}
//---------------------------------------------------------------------------
int CharList::Trim()
{
 return TrimLeft()+TrimRight();
}
//---------------------------------------------------------------------------
int CharList::Replace(char a, char b)
{
 CharListElem * pointer = first;
 int repl = 0;
 while(pointer)
 {
	if (pointer->value==a)
	{
	 pointer->value=b;
	 repl++;
	}
	pointer = pointer->to_next_pointer;
 }
 return repl;
}
//---------------------------------------------------------------------------
long CharList::ToInt()
{
 //int len = Length();
 int i;
 int sign=1;
 long num=0;
 CharListElem * pointer = first;
 if (first->value == '-')
 {
	pointer = pointer->to_next_pointer;
	sign=-1;
 }
 while(1)
 {
	if (pointer->value>='0' && pointer->value<='9')
	 num=num*10 + pointer->value - '0';
	else return 0;
	if (!(pointer=pointer->to_next_pointer) || pointer->value=='.') break;
 }
 return num*sign;
}
//---------------------------------------------------------------------------
double CharList::ToFloat()
{
 int num=0;
 double flt=1;
 int dec;
 dec=Find('.');
 if(dec==-1)
 {
	return ToInt();
 }
 else
 {
	CharList tmp = *this;
	CharList tmp_f = tmp.Split(dec);
	num=tmp.ToInt();
	tmp_f.Delete(0);
	for(int i=0; i<tmp_f.Length(); i++)
	 flt/=10;
	 flt*=tmp_f.ToInt();
 }
 return num+flt;
}
//---------------------------------------------------------------------------
CharList::operator char *()
{
 CharListElem * pointer = first;
#ifndef DONT_USE_OSTRSTREAM
 ostrstream temp;
 temp << first->value;
 while(pointer = pointer->to_next_pointer)
 temp << pointer->value;
 temp << ends;
 return temp.str();
#else
 char * temp = new char[Length()];
 long i=1;
 temp[0]=first->value;
 while(pointer = pointer->to_next_pointer)
 temp[i++] = pointer->value;
 return temp; //but YOU must delete it!!
#endif
}
//---------------------------------------------------------------------------
ostream& operator<<(ostream& s, CharList& a)
{
 CharListElem * pointer = a.first;
 if (pointer->value!=NULL)
	s << pointer->value;
 while(pointer->to_next_pointer != NULL)
 {
	pointer = pointer->to_next_pointer;
	s << pointer->value;
 }
 return s;
}
//---------------------------------------------------------------------------
istream& operator>>(istream& s, CharList& a)
{
 a.Clear();
 char tmp;
 CharListElem * pointer = a.first;
 if(s.read(&tmp,1) && tmp!='\n')
	a.first->value  =tmp;
 else
	return s;
 while(s.read(&tmp,1) && tmp!='\n')
	pointer=pointer->to_next_pointer= new CharListElem(tmp);
 return s;
}
//---------------------------------------------------------------------------
CharList& operator<< (CharList& a, istream &s)
{
 CharList tmp;
 s >> tmp;
 a += tmp;
 return a;
}
//---------------------------------------------------------------------------
CharList& operator<< (CharList& a, const char * s)
{
 CharList tmp(s);
 a += tmp;
 return a;
}
//---------------------------------------------------------------------------
CharList& operator<< (CharList& a, const double &s)
{
 CharList tmp(s);
 a += tmp;
 return a;
}
//---------------------------------------------------------------------------
unsigned short int CharList::operator!()
{
 return IsEmpty();
}
//---------------------------------------------------------------------------
CharList& CharList::operator= (const CharList& source)
{
	this->~CharList();
	CharListElem * pointer1; //source
	CharListElem * pointer2; //copy
	pointer1 = source.first;
	pointer2 = first = new CharListElem (pointer1->value);
	while (pointer1 = pointer1->to_next_pointer)
	pointer2 = pointer2->to_next_pointer = new CharListElem(pointer1->value);
	return *this;
}
//---------------------------------------------------------------------------
CharList& CharList::operator= (char* source)
{
	this->~CharList();
	CharListElem * pointer1; //this
	pointer1 = first = new CharListElem (*(source++));
	while (*source)
	pointer1 = pointer1->to_next_pointer = new CharListElem(*(source++));
	return *this;
}
//---------------------------------------------------------------------------
CharList& CharList::operator+= (const CharList& source)
{
	this->Add(this->Length(), source);
	return *this;
}
//---------------------------------------------------------------------------
CharList& CharList::operator+= (char* source)
{
	this->Add(this->Length(), source);
	return *this;
}
//---------------------------------------------------------------------------
CharList& CharList::operator+= (char source)
{
	this->Add(this->Length(), source);
	return *this;
}
//---------------------------------------------------------------------------
char& CharList::operator[] (unsigned long num)
{
	if(num>Length()-1)
	{
		cout << "You have asked for not-existing string element, "
                        "so the last existing element was returned!"<<endl;
		num=Length()-1;
	//WARNING! It's still not well adapted procedure -
	//it's better to THINK is it able by your procedure
	//to ask for char above the limits... else... results may vary...
	}
	CharListElem* pointer=first;
	for(long pos=0;pos<num;pos++)
		pointer=pointer->to_next_pointer;
	return pointer->value;
}
//---------------------------------------------------------------------------
CharList operator+ (const CharList& ch1, const CharList& ch2)
{
	CharList ch3(ch1);
	ch3.Add(ch3.Length(), ch2);
	return ch3;
}
//---------------------------------------------------------------------------
CharList operator+ (const CharList& ch1, char * ch2)
{
	CharList ch3(ch1);
	ch3.Add(ch3.Length(), ch2);
	return ch3;
}
//---------------------------------------------------------------------------
CharList operator+ (const CharList& ch1, char ch2)
{
	CharList ch3(ch1);
	ch3.Add(ch3.Length(), ch2);
	return ch3;
}
//---------------------------------------------------------------------------
unsigned short int operator== (const CharList& ch1, const CharList& ch2)
{
	CharListElem* pointer1 = ch1.first;
	CharListElem* pointer2 = ch2.first;
	do
	{
		if(!pointer1)
		{
			if(!pointer2) return 1;
			else return 0;
		}
		else if(!pointer2) return 0;
		else if(pointer1->value!=pointer2->value) return 0;
		pointer1=pointer1->to_next_pointer;
		pointer2=pointer2->to_next_pointer;
	}
	while(1);
}
//---------------------------------------------------------------------------
unsigned short int operator== (const CharList& ch1, const char * ch2)
{
CharListElem* pointer1 = ch1.first;
do
{
if(!pointer1)
{
if(!(*ch2)) return 1;
else return 0;
}
else if(!(*ch2)) return 0;
else if(pointer1->value!=*ch2) return 0;
pointer1=pointer1->to_next_pointer;
ch2++;
}
while(1);
}
//---------------------------------------------------------------------------
unsigned short int operator< (const CharList& ch1, const CharList& ch2)
{
CharListElem* pointer1=ch1.first;
CharListElem* pointer2=ch2.first;
do
{
if(!pointer2) return 0;
else if(!pointer1) return 1;
else if(pointer1->value<pointer2->value) return 1;
pointer1=pointer1->to_next_pointer;
pointer2=pointer2->to_next_pointer;
}
while(1);
}
//---------------------------------------------------------------------------
unsigned short int operator< (const CharList& ch1, const char * ch2)
{
CharListElem* pointer1=ch1.first;
do
{
if(!(*ch2)) return 0;
else if(!pointer1) return 1;
else if(pointer1->value<*ch2) return 1;
pointer1=pointer1->to_next_pointer;
ch2++;
}
while(1);
}
//---------------------------------------------------------------------------
unsigned short int operator> (const CharList& ch1, const CharList& ch2)
{
return (ch2<ch1);
}
//---------------------------------------------------------------------------
unsigned short int operator> (const CharList& ch1, const char* ch2)
{
CharList tmp(ch2);
return (tmp<ch1);
}
//---------------------------------------------------------------------------
unsigned short int operator<= (const CharList& ch1, const CharList& ch2)
{
CharListElem* pointer1 = ch1.first;
CharListElem* pointer2 = ch2.first;
do
{
if(!pointer1) return 1;
else if(!pointer2) return 0;
else if(pointer1->value<pointer2->value) return 1;
else if(pointer1->value>pointer2->value) return 0;
pointer1=pointer1->to_next_pointer;
pointer2=pointer2->to_next_pointer;
}
while(1);
}
//---------------------------------------------------------------------------
unsigned short int operator<= (const CharList& ch1,const  char * ch2)
{
CharListElem* pointer1 = ch1.first;
do
{
if(!pointer1) return 1;
else if(!(*ch2)) return 0;
else if(pointer1->value<*ch2) return 1;
else if(pointer1->value>*ch2) return 0;
pointer1=pointer1->to_next_pointer;
ch2++;
}
while(1);
}
//---------------------------------------------------------------------------
unsigned short int operator>= (const CharList& ch1, const CharList& ch2)
{
return (ch2<=ch1);
}
//---------------------------------------------------------------------------
unsigned short int operator>= (const CharList& ch1, const char * ch2)
{
CharList tmp(ch2);
return (tmp<=ch1);
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
#endif
//---------------------------------------------------------------------------
/*___________[END OF LIBRARY CODE SECTION]______________________*/
/*___________[BEGIN OF DEMO CODE SECTION]_______________________*/

/* //This is a simple demo code - just uncomment it, compile & run...

int main()
{
 DynaChar a("-1234.5");
 DynaChar x("x");
 cout<< "---------------------------------------" << endl;
 a<<"abc" ;
 a.Delete(1,2);
 //a << 1023.0 << x;
 a << 120.2 << x;
 cout << a <<endl;
 a<<x;
 cout << a <<endl;
 //a.~CharList();
 //delete a;
 cout <<"a teraz "<<a<<endl;
 cout << (a<x) << endl;
 cout<< "---------------------------------------" << endl;
 return 0;
}

*/

/*___________[END OF DEMO CODE SECTION]_______________________*/