--- parser3/src/include/pa_pool.h	2003/01/31 12:10:44	1.86.2.21
+++ parser3/src/include/pa_pool.h	2003/02/03 13:01:06	1.86.2.24
@@ -1,7 +1,7 @@
 /** @file
 	Parser: Parser: reference counting classes decls.
 
-	Copyright (c) 2001, 2003 ArtLebedev Group (http://www.artlebedev.com)
+	Copyright (c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com)
 
 	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */
@@ -9,7 +9,7 @@
 #ifndef PA_POOL_H
 #define PA_POOL_H
 
-static const char* IDENT_POOL_H="$Date: 2003/01/31 12:10:44 $";
+static const char* IDENT_POOL_H="$Date: 2003/02/03 13:01:06 $";
 
 // include
 
@@ -70,7 +70,7 @@ public:
 
 	//{@ helpers
 	void *copy(const void *buf, const size_t size);
-	char *copy(const char *cstr);
+	char *copy(const char* cstr);
 	//}@
 
 	//{@ source charset
@@ -86,7 +86,7 @@ public:
 #ifdef XML
 
 	/// @see Charset::transcode_cstr(xmlChar *s);
-	const char *transcode_cstr(xmlChar *s);
+	const char* transcode_cstr(xmlChar *s);
 	/// @see Charset::transcode(xmlChar *s);
 	String& transcode(xmlChar *s
 #ifndef NO_STRING_ORIGIN
@@ -94,15 +94,15 @@ public:
 #endif
 		);
 	/// @see Charset::transcode_cstr(GdomeDOMString *s);
-	const char *transcode_cstr(GdomeDOMString *s);
+	const char* transcode_cstr(GdomeDOMString *s);
 	/// @see Charset::transcode(GdomeDOMString *s);
 	String& transcode(GdomeDOMString *s
 #ifndef NO_STRING_ORIGIN
 		, const String *origin
 #endif
 		);
-	/// @see Charset::transcode_cstr(const char *buf, size_t buf_size=0);
-	xmlChar *transcode_buf2xchar(const char *buf, size_t buf_size=0);
+	/// @see Charset::transcode_cstr(const char* buf, size_t buf_size=0);
+	xmlChar *transcode_buf2xchar(const char* buf, size_t buf_size=0);
 	/// @see Charset::transcode(const String& s)
 	GdomeDOMString_auto_ptr transcode(const String& s);
 
@@ -196,10 +196,10 @@ public:
 	void *calloc(size_t size) const { return fpool->calloc(size); }
 	void register_cleanup(void (*cleanup) (void *), void *data) { fpool->register_cleanup(cleanup, data); }
 	void *copy(const void *buf, const size_t size) { return fpool->copy(buf, size); }
-	char *copy(const char *cstr) { return fpool->copy(cstr); }
+	char *copy(const char* cstr) { return fpool->copy(cstr); }
 #ifdef XML
 
-	const char *transcode_cstr(GdomeDOMString *s) { return fpool->transcode_cstr(s); }
+	const char* transcode_cstr(GdomeDOMString *s) { return fpool->transcode_cstr(s); }
 	String& transcode(GdomeDOMString *s
 #ifndef NO_STRING_ORIGIN
 		, const String *origin
@@ -284,6 +284,8 @@ public:
 	}
 	template<class B> object_ptr(const object_ptr<B>& src) {
 		this->ptr=src.get();
+		if(ptr)
+			ptr->ref();
 	}
 	object_ptr(const object_ptr<T>& src) {
 		ptr=src.get();
@@ -319,7 +321,7 @@ public:
 	operator bool() const {
 		return get()!=0;
 	}
-	operator !() const {
+	bool operator !() const {
 		return get()==0;
 	}
 };
@@ -330,48 +332,43 @@ public:
 //	typedef object_ptr<name> name##Ptr; \
 //	const object_ptr<name> name##PtrZero(0);
 
-/// TEMPLATE CLASS smart_ptr, stolen from stl:auto_ptr
+/// TEMPLATE CLASS smart_ptr, stolen  from stl:auto_ptr & renamed field/params [not compiled on gcc]
 template<class T>
 	class smart_ptr {
+	bool owns;
+	T *ptr;
 public:
 	typedef T element_type;
-	explicit smart_ptr(T *_P = 0)
-		: _Owns(_P != 0), _Ptr(_P) {}
-	smart_ptr(const smart_ptr<T>& _Y)
-		: _Owns(_Y._Owns), _Ptr(_Y.release()) {}
-	smart_ptr<T>& operator=(const smart_ptr<T>& _Y)
-		{if (this != &_Y)
-			{if (_Ptr != _Y.get())
-				{if (_Owns)
-					delete _Ptr;
-				_Owns = _Y._Owns; }
-			else if (_Y._Owns)
-				_Owns = true;
-			_Ptr = _Y.release(); }
+	explicit smart_ptr(T *aptr = 0)
+		: owns(aptr != 0), ptr(aptr) {}
+	smart_ptr(const smart_ptr<T>& src)
+		: owns(src.owns), ptr(src.release()) {}
+	smart_ptr<T>& operator=(const smart_ptr<T>& src)
+		{if (this != &src)
+			{if (this.ptr != src.get())
+				{if (owns)
+					delete this.ptr;
+				owns = src.owns; }
+			else if (src.owns)
+				owns = true;
+			this.ptr = src.release(); }
 		return (*this); }
 	~smart_ptr()
-		{if (_Owns)
-			delete _Ptr; }
+		{if (owns)
+			delete this.ptr; }
 	T& operator*() const
 		{return (*get()); }
 	T *get() const
-		{return (_Ptr); }
+		{return (this.ptr); }
 	T *release() const
-		{((smart_ptr<T> *)this)->_Owns = false;
-		return (_Ptr); }
-	// so one could smart_ptr<const T> = smart_ptr<T>
-	operator smart_ptr<const T>() const {
-		return *this;
-	}
+		{((smart_ptr<T> *)this)->owns = false;
+		return (this.ptr); }
 	operator bool() const {
 		return get()!=0;
 	}
 	operator T*() const {
-		return _Ptr;
+		return ptr;
 	}
-private:
-	bool _Owns;
-	T *_Ptr;
 	};
 
 // convinient types