--- parser3/src/main/pa_common.C	2001/03/11 08:16:35	1.6
+++ parser3/src/main/pa_common.C	2001/03/19 16:44:01	1.15
@@ -1,9 +1,9 @@
-/*
+/** @file
 	Parser
-	Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
-	Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
+	Copyright(c) 2001 ArtLebedev Group(http://www.artlebedev.com)
+	Author: Alexander Petrosyan <paf@design.ru>(http://design.ru/paf)
 
-	$Id: pa_common.C,v 1.6 2001/03/11 08:16:35 paf Exp $
+	$Id: pa_common.C,v 1.15 2001/03/19 16:44:01 paf Exp $
 */
 
 #ifdef HAVE_CONFIG_H
@@ -15,10 +15,16 @@
 #include <sys/stat.h>
 #include <io.h>
 #include <stdio.h>
+#include <string.h>
 
 #include "pa_common.h"
 #include "pa_types.h"
 #include "pa_exception.h"
+#include "pa_pool.h"
+#include "pa_globals.h"
+#include "pa_value.h"
+#include "pa_hash.h"
+#include "pa_string.h"
 
 #ifdef WIN32
 
@@ -37,18 +43,18 @@ int __snprintf(char *b, size_t s, const
 
 #endif
 
-char *file_read(Pool& pool, char *fname, bool fail_on_read_problem) {
+char *file_read(Pool& pool, const char *fname, bool fail_on_read_problem) {
     int f;
     struct stat finfo;
-    if (fname && !stat(fname,&finfo) && (f=open(fname,O_RDONLY
+    if(fname && !stat(fname,&finfo) &&(f=open(fname,O_RDONLY
 #ifdef WIN32
 		|O_TEXT
 #endif
-		))>=0){
+		))>=0) {
 		/*if(exclusive)
 			flock(f, LOCK_EX);*/
 
-		char *result=static_cast<char *>(pool.malloc(finfo.st_size+1));
+		char *result=(char *)pool.malloc(finfo.st_size+1);
 		int read_size=read(f,result,finfo.st_size);
 		if(read_size>=0 && read_size<=finfo.st_size) 
 			result[read_size]='\0';
@@ -58,8 +64,146 @@ char *file_read(Pool& pool, char *fname,
 		return result;//prepare_config(result, remove_empty_lines);
     }
 	if(fail_on_read_problem)
-		POOL_THROW(0,0,
+		PTHROW(0,0,
 			0,
 			"use: can not read '%s' file", fname);
-    return NULL;
+    return 0;
 }
+
+char *getrow(char **row_ref, char delim) {
+    char *result=*row_ref;
+    if(result) {
+		*row_ref=strchr(result, delim);
+		if(*row_ref) 
+			*((*row_ref)++)=0; 
+		else if(!*result) 
+			return 0;
+    }
+    return result;
+}
+
+char *lsplit(char *string_ref, char delim) {
+    if(string_ref) {
+		char *v=strchr(string_ref, delim);
+		if(v) {
+			*v=0;
+			return v+1;
+		}
+    }
+    return 0;
+}
+
+char *lsplit(char **string_ref, char delim) {
+    char *result=*string_ref;
+	char *next=lsplit(*string_ref, delim);
+    *string_ref=next;
+    return result;
+}
+
+char *rsplit(char *string, char delim) {
+    if(string){
+		char *v=strrchr(string, delim);
+		if (v){
+			*v=0;
+			return v+1;
+		}
+    }
+    return NULL;	
+}
+
+char *format(Pool& pool, double value, char *fmt) {
+	char *result=(char *)pool.malloc(MAX_NUMBER);
+	if(fmt)
+		if(strpbrk(fmt, "diouxX"))
+			if(strpbrk(fmt, "ouxX"))
+				snprintf(result, MAX_NUMBER, fmt, (uint)value );
+			else
+				snprintf(result, MAX_NUMBER, fmt, (int)value );
+		else
+			snprintf(result, MAX_NUMBER, fmt, value);
+	else
+		snprintf(result, MAX_NUMBER, "%d", (int)value);
+	
+	return result;
+}
+
+size_t stdout_write(const char *buf, size_t size) {
+#ifdef WIN32
+	do{
+		int chunk_written=fwrite(buf, 1, min(8*0x400, size), stdout);
+		if(chunk_written<=0)
+			break;
+		size-=chunk_written;
+		buf+=chunk_written;
+	} while(size>0);
+
+	return size;
+#else
+	return fwrite(buf, 1, size, stdout);
+#endif
+}
+
+const char *unescape_chars(Pool& pool, const char *cp, int len) {
+	char *s=(char *)pool.malloc(len + 1);
+	enum EscapeState {
+		EscapeRest,
+		EscapeFirst,
+		EscapeSecond
+	} escapeState=EscapeRest;
+	int escapedValue=0;
+	int srcPos=0;
+	int dstPos=0;
+	while(srcPos < len) {
+		int ch=cp[srcPos];
+		switch(escapeState) {
+			case EscapeRest:
+			if(ch=='%') {
+				escapeState=EscapeFirst;
+			} else if(ch=='+') {
+				s[dstPos++]=' ';
+			} else {
+				s[dstPos++]=ch;	
+			}
+			break;
+			case EscapeFirst:
+			escapedValue=hex_value[ch] << 4;	
+			escapeState=EscapeSecond;
+			break;
+			case EscapeSecond:
+			escapedValue +=hex_value[ch];
+			s[dstPos++]=escapedValue;
+			escapeState=EscapeRest;
+			break;
+		}
+		srcPos++;
+	}
+	s[dstPos]=0;
+	return s;
+}
+
+static void append_attribute_subattribute(const Hash::Key& akey, Hash::Value *avalue, 
+										  void *info) {
+	if(akey==VALUE_NAME)
+		return;
+
+	// ...; charset=windows1251
+	String *string=static_cast<String *>(info);
+	string->APPEND_CONST("; ");
+	string->append(akey, String::Untaint_lang::HEADER, true);
+	string->APPEND_CONST("=");
+	string->append(static_cast<Value *>(avalue)->as_string(), 
+		String::Untaint_lang::HEADER, true);
+}
+const String& attributed_meaning_string(Value *meaning) {
+	String &result=*new(meaning->pool()) String(meaning->pool());
+	if(Hash *hash=meaning->get_hash()) {
+		// $value(value) $subattribute(subattribute value)
+		if(Value *value=static_cast<Value *>(hash->get(*value_name)))
+			result.append(value->as_string(), String::Untaint_lang::HEADER, true);
+
+		hash->foreach(append_attribute_subattribute, &result);
+	} else // result value
+		result.append(meaning->as_string(), String::Untaint_lang::HEADER, true);
+
+	return result;
+}
\ No newline at end of file