--- parser3/src/main/pa_common.C	2001/02/25 08:50:14	1.3
+++ parser3/src/main/pa_common.C	2001/03/23 13:08:10	1.22
@@ -1,21 +1,31 @@
-/*
-  $Id: pa_common.C,v 1.3 2001/02/25 08:50:14 paf Exp $
+/** @file
+	Parser: commonly functions.
+
+	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.22 2001/03/23 13:08:10 paf Exp $
 */
 
-#ifdef HAVE_CONFIG_H
-#	include "pa_config.h"
-#endif
+#include "pa_config_includes.h"
 
 #include <fcntl.h>
-#include <sys/types.h>
 #include <sys/stat.h>
 #include <io.h>
 #include <stdio.h>
+#include <errno.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
+#if _MSC_VER
 
 int __vsnprintf(char *b, size_t s, const char *f, va_list l) {
 	int r=_vsnprintf(b, --s, f, l);
@@ -32,18 +42,19 @@ int __snprintf(char *b, size_t s, const
 
 #endif
 
-char *file_read(Pool& pool, char *fname) {
+
+char *file_read_text(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';
@@ -52,5 +63,191 @@ char *file_read(Pool& pool, char *fname)
 		close(f);
 		return result;//prepare_config(result, remove_empty_lines);
     }
-    return NULL;
+	if(fail_on_read_problem)
+		PTHROW(0,0,
+			0,
+			"can not read '%s' file", fname);
+    return 0;
+}
+
+void file_write(Pool& pool, 
+				const char *fname, 
+				const char *data, size_t size, 
+				bool as_text/*,
+				bool exclusive*/) {
+	if(fname) {
+		int f;
+		if(access(fname, F_OK)!=0) {/*no*/
+			if((f=open(fname,O_WRONLY|O_CREAT|_O_BINARY,0666))>0)
+				close(f);
+		}
+		if(access(fname, R_OK|W_OK)==0) {
+			int mode=O_RDWR
+#ifdef WIN32
+				|O_TRUNC
+#endif
+			;
+			mode|=as_text?_O_TEXT:_O_BINARY;
+			if((f=open(fname,mode,0666))>=0) {
+				/*if(exclusive)
+					flock(f, LOCK_EX);*/
+				
+				if(size) write(f,data,size);
+#ifndef WIN32
+				ftruncate(f,size);
+#endif
+				/*if(exclusive)
+					flock(f, LOCK_UN);*/
+				close(f);
+				return;
+			}
+		}
+	}
+	if(fname)
+		PTHROW(0, 0,
+			0,
+			"file_write('%s'): %s (#%d)", 
+				fname, strerror(errno), errno);
+	else
+		PTHROW(0, 0,
+			0,
+			"file_write: no filename specified");
+}
+
+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::Val *avalue, 
+										  void *info) {
+	if(akey==VALUE_NAME)
+		return;
+
+	// ...; charset=windows1251
+	String *string=static_cast<String *>(info);
+	string->APPEND_CONST("; ");
+	string->append(akey, String::UL_HEADER, true);
+	string->APPEND_CONST("=");
+	string->append(static_cast<Value *>(avalue)->as_string(), 
+		String::UL_HEADER, true);
+}
+const String& attributed_meaning_to_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::UL_HEADER, true);
+
+		hash->foreach(append_attribute_subattribute, &result);
+	} else // result value
+		result.append(meaning.as_string(), String::UL_HEADER, true);
+
+	return result;
+}
\ No newline at end of file