--- parser3/src/main/pa_string.C	2002/02/20 10:40:08	1.140
+++ parser3/src/main/pa_string.C	2002/02/28 09:35:41	1.147
@@ -4,7 +4,7 @@
 	Copyright (c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)
 	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 
-	$Id: pa_string.C,v 1.140 2002/02/20 10:40:08 paf Exp $
+	$Id: pa_string.C,v 1.147 2002/02/28 09:35:41 paf Exp $
 */
 
 #include "pcre.h"
@@ -32,8 +32,6 @@ String::String(Pool& apool, const char *
 	last_chunk=&head;
 	head.count=CR_PREALLOCATED_COUNT;
 	append_here=head.rows;
-	initial_head_link=0;
-	link_row=&head.rows[head.count];
 
 	if(src)
 		if(tainted)
@@ -41,71 +39,12 @@ String::String(Pool& apool, const char *
 		else
 			APPEND_CLEAN(src, src_size, 0, 0);
 }
-/*
-String::String(const String& src) :	
-	Pooled(src.pool()) {
-	head.count=CR_PREALLOCATED_COUNT;
-	
-	uint src_used_rows=src.used_rows();
-	if(src_used_rows<=head.count) {
-		// all new rows fit size_to preallocated area
-		last_chunk=&head;
-		uint curr_chunk_rows=head.count;
-		memcpy(head.rows, src.head.rows, sizeof(Chunk::Row)*src_used_rows);
-		append_here=&head.rows[src_used_rows];
-		link_row=&head.rows[curr_chunk_rows];
-	} else {
-		// warning: 
-		//   heavily relies on the fact 
-		//   "preallocated area is the same for all strings"
-		//
-		// info:
-		//   allocating only enough mem to fit src string rows
-		//   next append would allocate a new chunk
-		//
-		// new rows don't fit size_to preallocated area: splitting size_to two chunks
-		// preallocated chunk src to constructing head
-		memcpy(head.rows, src.head.rows, sizeof(Chunk::Row)*head.count);
-		// remaining rows size_to new_chunk
-		uint curr_chunk_rows=src_used_rows-head.count;
-		last_chunk=static_cast<Chunk *>(
-			malloc(sizeof(Chunk::count_type)+sizeof(Chunk::Row)*curr_chunk_rows+sizeof(Chunk *), 9));
-		last_chunk->count=curr_chunk_rows;
-		append_here=link_row=&last_chunk->rows[last_chunk->count];
-
-		Chunk *old_chunk=src.head.rows[src.head.count].link; 
-		Chunk::Row *new_rows=last_chunk->rows;
-		uint rows_left_to_copy=last_chunk->count;
-		while(true) {
-			Chunk::count_type old_count=old_chunk->count;
-			Chunk *next_chunk=old_chunk->rows[old_count].link;
-			if(next_chunk) {
-				// not last source chunk
-				// taking it all
-				memcpy(new_rows, old_chunk->rows, sizeof(Chunk::Row)*old_count);
-				new_rows+=old_count;
-				rows_left_to_copy-=old_count;
-
-				old_chunk=next_chunk;
-			} else {
-				// the last source chunk
-				// taking only those rows of chunk that _left_to_copy
-				memcpy(new_rows, old_chunk->rows, sizeof(Chunk::Row)*rows_left_to_copy);
-				break;
-			}
-		}
-	}
-	link_row->link=0;
-}
-*/
 
 String::String(const String& src) :	
 	Pooled(src.pool()) {
 	last_chunk=&head;
 	head.count=CR_PREALLOCATED_COUNT;
 	append_here=head.rows;
-	initial_head_link=0;
-	link_row=&head.rows[head.count];
 
 	append(src, UL_UNSPECIFIED);
 }
@@ -115,7 +54,6 @@ size_t  String::size() const {
 	STRING_FOREACH_ROW(
 			result+=row->item.size;
 	);
-break2:
 	return result;
 }
 
@@ -125,28 +63,27 @@ uint String::used_rows() const {
 	STRING_FOREACH_ROW(
 		result++;
 	);
-break2:
 	return result;
 }
 void String::expand() {
-	Chunk::count_type new_chunk_count=last_chunk->count+CR_GROW_COUNT;
+	uint new_chunk_count=last_chunk->count+CR_GROW_COUNT;
 	if(new_chunk_count>max_integral(Chunk::count_type))
 		new_chunk_count=max_integral(Chunk::count_type);
 
-	last_chunk=static_cast<Chunk *>(
+	Chunk *new_chunk=static_cast<Chunk *>(
 		malloc(sizeof(Chunk::count_type)+sizeof(Chunk::Row)*new_chunk_count+sizeof(Chunk *), 10));
-	last_chunk->count=new_chunk_count;
-	link_row->link=last_chunk;
+	new_chunk->rows[new_chunk->count=new_chunk_count].link=0;
+	last_chunk->rows[last_chunk->count].link=new_chunk;
+	
+	last_chunk=new_chunk;
 	append_here=last_chunk->rows;
-	link_row=&last_chunk->rows[last_chunk->count];
-	link_row->link=0;
 }
 
 String& String::real_append(STRING_APPEND_PARAMS) {
 	if(!last_chunk) // growth stopped [we're appended as string to somebody]
 		throw Exception(0, 0,
 			this,
-			"string growth stopped");
+			"string growth stopped (append cstr)");
 
 	if(!src)
 		return *this;
@@ -206,7 +143,6 @@ uint String::hash_code() const {
 	STRING_FOREACH_ROW(
 			result=Hash::generic_code(result, row->item.ptr, row->item.size);
 	);
-break2:
 	return result;
 }
 
@@ -378,14 +314,14 @@ const Origin& String::origin() const {
 		return empty_origin;
 	}
 	
-	// determining origin by last appended piece
-	// because first one frequently constant. 
+	// determining origin by first piece or last appended piece
+	// because any of them can be constant=without origin: 
 	// ex: ^load[/file] "document_root" + "/file"
 	// when last peice is constant, 
 	// ex: parser_root_auto_path{dynamic} / auto.p{const}
 	// using first piece
-	Origin& last_origin=append_here[-1].item.origin;
-	return last_origin.file ? last_origin : head.rows[0].item.origin;
+	Origin& first_origin=head.rows[0].item.origin;
+	return first_origin.file ? first_origin : append_here[-1].item.origin;
 }
 #endif
 
@@ -655,137 +591,87 @@ String& String::change_case(Pool& pool,
 		break; // never
 	}	
 
-	const Chunk *chunk=&head; 
-	do {
-		const Chunk::Row *row=chunk->rows;
-		for(Chunk::count_type i=0; i<chunk->count; i++, row++) {
-			if(row==append_here)
-				goto break2;
-
-			char *new_cstr=(char *)pool.malloc(row->item.size, 12);
-			char *dest=new_cstr;
-			const char *src=row->item.ptr; 
-			for(int size=row->item.size; size--; src++) {
-				unsigned char c=a[(unsigned char)*src];
-				if(b)
-					c=b[c];
+	STRING_FOREACH_ROW(
+		char *new_cstr=(char *)pool.malloc(row->item.size, 12);
+		char *dest=new_cstr;
+		const char *src=row->item.ptr; 
+		for(int size=row->item.size; size--; src++) {
+			unsigned char c=a[(unsigned char)*src];
+			if(b)
+				c=b[c];
 
-				*dest++=(char)c;
-			}
-			
-			result.APPEND(new_cstr, row->item.size, 
-				row->item.lang,
-				row->item.origin.file, row->item.origin.line);
+			*dest++=(char)c;
 		}
-		chunk=row->link;
-	} while(chunk);
-break2:
+		
+		result.APPEND(new_cstr, row->item.size, 
+			row->item.lang,
+			row->item.origin.file, row->item.origin.line);
+	);
 
 	return result;
 }
 
 void String::join_chain(Pool& pool, 
-					   uint& ai, const Chunk*& achunk, const Chunk::Row*& arow,
+					   const Chunk*& achunk, const Chunk::Row*& arow, uint& acountdown, 
 					   uchar& joined_lang, const char *& joined_ptr, size_t& joined_size) const {
 	joined_lang=arow->item.lang;
 	
 	// calc size
 	joined_size=0;
 	{
-		uint start_i=ai;
-		const Chunk::Row *start_row=arow;
-		const Chunk *chunk=achunk;
-		do {
-			const Chunk::Row *row=start_row;
-			for(uint i=start_i; i<chunk->count; i++, row++) {
-				if(row==append_here)
-					goto break21;
-				
-				if(row->item.lang==joined_lang)
-					joined_size+=row->item.size;
-				else
-					goto break21;
-			}
-			if(chunk=row->link) {
-				start_i=0;
-				start_row=chunk->rows;
-			} else
+		const Chunk* chunk=achunk;
+		const Chunk::Row* row=arow;
+		uint countdown=acountdown;
+		STRING_PREPARED_FOREACH_ROW(*this, 
+			if(row->item.lang==joined_lang)
+				joined_size+=row->item.size;
+			else
 				break;
-		} while(true);
-break21:;
+		);
 	}
 
 	// if one row, return simply itself
 	if(joined_size==arow->item.size) {
 		joined_ptr=arow->item.ptr;
-		ai++; arow++;
-		if(ai==achunk->count) {
-			if(achunk=arow->link) {
-				ai=0;
-				arow=achunk->rows;
-			}
-		}
 	} else {
 		// join adjacent rows
-		char *ptr=(char *)pool.malloc(joined_size,13);
+		char *ptr=(char *)pool.malloc(joined_size,13);  
 		joined_ptr=ptr;
-		uint start_i=ai;
-		const Chunk::Row *start_row=arow;
-		const Chunk *chunk=achunk;
-		uint i;
-		const Chunk::Row *row;
-		do {
-			row=start_row;
-			for(i=start_i; i<chunk->count; i++, row++) {
-				if(row==append_here)
-					goto break22;
-				
-				if(row->item.lang==joined_lang) {
-					memcpy(ptr, row->item.ptr, row->item.size);
-					ptr+=row->item.size;
-				} else
-					goto break22;
-			}
-			if(chunk=row->link) {
-				start_i=0;
-				start_row=chunk->rows;
+
+		const Chunk* chunk=achunk;
+		const Chunk::Row* row=arow;
+		uint countdown=acountdown;
+		STRING_PREPARED_FOREACH_ROW(*this, 
+			if(row->item.lang==joined_lang) {
+				memcpy(ptr, row->item.ptr, row->item.size);  ptr+=row->item.size;
 			} else
-				break;
-		} while(true);
-break22:;
+				break; // before non-ours
+		);
 		
-		// return joined rows
-		ai=i;
-		arow=row;
-		achunk=chunk;
+		// set pointers after joined piece
+		achunk=chunk;  arow=row;  acountdown=countdown;
+		// & one step back, see String::reconstruct
+		--arow;  ++acountdown;
 	}
 }
 
 String& String::reconstruct(Pool& pool) const {
 	//_asm int 3;
 	String& result=*new(pool) String(pool);
-	const Chunk *chunk=&head; 
-	const Chunk::Row *row=chunk->rows;
-	for(uint i=0; i<chunk->count; ) {
-		if(row==append_here)
-			break;
-
+	STRING_FOREACH_ROW(
 		uchar joined_lang;
 		const char *joined_ptr;
 		size_t joined_size;
-#ifndef NO_STRING_ORIGIN
+IFNDEF_NO_STRING_ORIGIN(
 		const char *joined_origin_file=row->item.origin.file;
 		const size_t joined_origin_line=row->item.origin.line;
-#endif
-		join_chain(pool, i, chunk, row,
+);
+		join_chain(pool, chunk, row, countdown,
 			joined_lang, joined_ptr, joined_size);
 
 		result.APPEND(joined_ptr, joined_size, joined_lang,
 			joined_origin_file, joined_origin_line);
-
-		if(!chunk)
-			break;
-	}
+	);
 
 	return result;
 };
@@ -818,7 +704,6 @@ String& String::replace_in_reconstructed
 			row->item.lang,
 			row->item.origin.file, row->item.origin.line);
 	);
-break2:
 	return result;
 }
 
@@ -916,8 +801,6 @@ void String::serialize(size_t prolog_siz
 		memcpy(cur, row->item.ptr, row->item.size);
 		cur+=row->item.size;
 	);
-break2:
-	;
 }
 void String::deserialize(size_t prolog_size, void *buf, size_t buf_size, const char *file) {
 	if(buf_size<=prolog_size)