--- parser3/src/main/pa_common.C	2001/03/13 16:38:24	1.11
+++ parser3/src/main/pa_common.C	2001/03/24 15:58:00	1.28
@@ -1,27 +1,32 @@
-/*
-	Parser
+
+/** @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.11 2001/03/13 16:38:24 paf Exp $
+	$Id: pa_common.C,v 1.28 2001/03/24 15:58:00 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 <string.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);
@@ -38,10 +43,12 @@ int __snprintf(char *b, size_t s, const
 
 #endif
 
-char *file_read(Pool& pool, const char *fname, bool fail_on_read_problem) {
+
+char *file_read_text(Pool& pool, const String& file_spec, bool fail_on_read_problem) {
     int f;
     struct stat finfo;
-    if(fname && !stat(fname,&finfo) &&(f=open(fname,O_RDONLY
+	char *fname=file_spec.cstr();
+    if(!stat(fname,&finfo) &&(f=open(fname,O_RDONLY
 #ifdef WIN32
 		|O_TEXT
 #endif
@@ -59,12 +66,49 @@ char *file_read(Pool& pool, const char *
 		return result;//prepare_config(result, remove_empty_lines);
     }
 	if(fail_on_read_problem)
-		PTHROW(0,0,
-			0,
-			"use: can not read '%s' file", fname);
+		PTHROW(0, 0,
+			&file_spec,
+			"read %s (#%d)", strerror(errno), errno);
     return 0;
 }
 
+void file_write(Pool& pool, 
+				const String& file_spec, 
+				const char *data, size_t size, 
+				bool as_text/*,
+				bool exclusive*/) {
+	char *fname=file_spec.cstr();
+	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;
+		}
+	}
+	PTHROW(0, 0,
+		&file_spec,
+		"write %s (#%d)", strerror(errno), errno);
+}
+
 char *getrow(char **row_ref, char delim) {
     char *result=*row_ref;
     if(result) {
@@ -77,9 +121,9 @@ char *getrow(char **row_ref, char delim)
     return result;
 }
 
-char *lsplit(char *string_ref, char delim) {
-    if(string_ref) {
-		char *v=strchr(string_ref, delim);
+char *lsplit(char *string, char delim) {
+    if(string) {
+		char *v=strchr(string, delim);
 		if(v) {
 			*v=0;
 			return v+1;
@@ -96,9 +140,9 @@ char *lsplit(char **string_ref, char del
 }
 
 char *rsplit(char *string, char delim) {
-    if(string){
+    if(string) {
 		char *v=strrchr(string, delim);
-		if (v){
+		if(v) {
 			*v=0;
 			return v+1;
 		}
@@ -111,13 +155,103 @@ char *format(Pool& pool, double value, c
 	if(fmt)
 		if(strpbrk(fmt, "diouxX"))
 			if(strpbrk(fmt, "ouxX"))
-				snprintf(result, MAX_NUMBER, fmt, (uint)value );
+				snprintf(result, MAX_NUMBER, fmt,(uint)value );
 			else
-				snprintf(result, MAX_NUMBER, fmt, (int)value );
+				snprintf(result, MAX_NUMBER, fmt,(int)value );
 		else
 			snprintf(result, MAX_NUMBER, fmt, value);
 	else
-		snprintf(result, MAX_NUMBER, "%d", (int)value);
+		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->for_each(append_attribute_subattribute, &result);
+	} else // result value
+		result.append(meaning.as_string(), String::UL_HEADER, true);
+
+	return result;
+}
+
+#ifdef WIN32
+void back_slashes_to_slashes(char *s) {
+	if(s)
+		for(; *s; s++)
+			if(*s=='\\')
+				*s='/';
+}
+#endif