GEEKING

CSG/sgCore/Core/O_UTIL/U_AVALUE.cpp

@@ -0,0 +1,44 @@
+#include "../sg.h"
+
+BOOL add_data_to_avalue(lpVLD vld, lpA_VALUE av, ULONG len, void* value)
+{
+
+  if(len <= MAX_INLINE_VALUE){ //    
+    memcpy(av->value.cv, value, len);
+    av->status = (UCHAR)len;
+    return TRUE;
+  }
+  else{ //  -    vld
+    av->status = A_NOT_INLINE;
+    return add_not_inline_data(vld, &av->value.ni, len, value);
+  }
+}
+
+BOOL load_data_from_avalue(lpA_VALUE av, ULONG *len, void* value)
+{
+  if(av->status == A_NOT_INLINE){
+    if(!load_vld_data(&av->value.ni.loc, av->value.ni.len, value))
+      return FALSE;
+     *len = av->value.ni.len;
+  }
+  else{
+    memcpy(value, av->value.cv, av->status);
+		*len = av->status;
+  }
+  return TRUE;
+}
+
+
+BOOL add_not_inline_data(lpVLD vld, lpNOT_INLINE ni, ULONG len,
+                         void* data)
+{
+	memset(ni, 0, sizeof(NOT_INLINE));
+  ni->loc = vld->viloc;
+  ni->len = len;
+  if(!add_vld_data(vld, len, data)) return FALSE;
+  if(!ni->loc.hpage) {
+    ni->loc.hpage  = vld->listh.hhead;
+    ni->loc.offset = sizeof(RAW);
+	}
+  return TRUE;
+}

CSG/sgCore/Core/O_UTIL/U_BUFFER.cpp

@@ -0,0 +1,271 @@
+#include "../sg.h"
+static ULONG total_stored = 0l, total_stored_last = 0l;
+static BOOL show_progress = FALSE;
+
+extern int errno;
+int buf_level = 0;        //   
+
+BOOL init_buf(lpBUFFER_DAT bd,char* name, BUFTYPE regim)
+{
+	int n_access = O_RDWR;
+	UINT mode =  0;
+	int	code;
+
+	if (regim == BUF_NEW)
+		n_access |= O_CREAT | O_TRUNC;
+  else if (regim == BUF_NEWINMEM)
+  {
+    n_access |= O_CREAT | O_TRUNC;	mode = 1;
+  }
+	else {
+		if (nb_access( name, 6) == -1)
+			n_access  = O_RDONLY;
+	}
+
+	buf_level++;
+	memset(bd,0,sizeof(BUFFER_DAT));  bd->handle = 0;
+	if ((bd->handle=nb_open(name,n_access, mode)) == 0) {
+		switch ( errno ) {
+			case EACCES: //	Permission denied
+				code = UE_OPEN_ACCES;
+				break;
+/*
+			case EINVACC://	Invalid access code
+				code = UE_OPEN_EINVACC;
+				break;
+*/
+			case EMFILE: //	Too many open files
+				code = UE_OPEN_EMFILE;
+				break;
+			case ENOENT: //	No such file or directory
+			default:
+				code = UE_OPEN_ENOENT;
+				break;
+		}
+//		u_handler_err(UE_OPEN_FILE,name);
+		u_handler_err(code);
+		return FALSE;
+	}
+	if ( (bd->buf = (char *)SGMalloc(SIZE_VPAGE)) == NULL ) {
+		nb_close(bd->handle);
+		u_handler_err(UE_NO_VMEMORY);
+		return FALSE;
+	}
+	bd->len_file = nb_filelength(bd->handle);
+	return TRUE;
+}
+
+void turn_story_data_progress(BOOL on)
+{
+	 show_progress = on;
+	 total_stored = total_stored_last = 0l;
+}
+
+BOOL story_data(lpBUFFER_DAT bd, ULONG len, void* data)
+{
+	ULONG  lentmp, cur_data;
+	char  *pdata;
+
+	if (show_progress)  {
+		total_stored += len;
+		if (total_stored - total_stored_last > 50000L) {
+//			wsprintf(st, "%ld", total_stored);
+//	   	AddDelim(st, GetIDS(IDS_MSG161)[0]);
+//			StatusBarShow(0, st, RGB_MAGENTA, DT_RIGHT);
+			total_stored_last = total_stored;
+		}
+	}
+	pdata = (char*)data;
+	cur_data = 0;
+	while (len) {
+    bd->flg_modify = 1;
+    if ( len + bd->cur_buf <= SIZE_VPAGE) {
+      memcpy(&bd->buf[bd->cur_buf],&pdata[cur_data],len);
+			bd->cur_buf += (WORD)len;
+      if (bd->len_buf < bd->cur_buf) bd->len_buf = bd->cur_buf;
+			break;
+		}
+		lentmp = SIZE_VPAGE- bd->cur_buf;
+    memcpy(&bd->buf[bd->cur_buf],&pdata[cur_data],lentmp);
+    nb_lseek(bd->handle,bd->p_beg,SEEK_SET);
+    if (nb_write(bd->handle, bd->buf, SIZE_VPAGE) != SIZE_VPAGE) { /*   */
+			u_handler_err(UE_WRITE_FILE);
+			return FALSE;
+		}
+    bd->p_beg += SIZE_VPAGE;
+    bd->flg_modify = 0;
+    bd->cur_buf = 0;
+    len -= lentmp;
+    cur_data += lentmp;
+    bd->len_buf = 0;
+  }
+	if ( bd->p_beg + bd->cur_buf > bd->len_file)
+		bd->len_file = bd->p_beg + bd->cur_buf;
+  return TRUE;
+}
+
+ULONG load_data(lpBUFFER_DAT bd, ULONG len, void* data)
+{
+  ULONG rezult;
+  int  lentmp, cur_data;
+  int  num_bytes;
+  char  *pdata;
+
+  rezult = 0;
+	pdata = (char*)data;
+	cur_data = 0;
+  if ( bd->flg_no_read ) data = NULL;
+
+	while (len) {
+		if ( len + bd->cur_buf <= bd->len_buf) {
+      if ( data ) memcpy(&pdata[cur_data],&bd->buf[bd->cur_buf],len);
+			rezult += len;
+			bd->cur_buf += ((WORD)len);
+			break;
+		}
+		if ( bd->len_buf <= bd->cur_buf ) {
+			lentmp = 0;
+			goto m;
+		}
+		lentmp = bd->len_buf - bd->cur_buf;
+    if ( data ) memcpy(&pdata[cur_data],&bd->buf[bd->cur_buf],lentmp);
+		rezult += lentmp;
+m:
+		if ( !flush_buf(bd) ) return FALSE;
+		if (lentmp) bd->p_beg += bd->len_buf;
+		else        bd->p_beg += bd->cur_buf;
+		if (nb_lseek(bd->handle,bd->p_beg,SEEK_SET) == 0xFFFFFFFF) return FALSE;
+		if ( (num_bytes = nb_read(bd->handle,bd->buf,SIZE_VPAGE)) == 0xFFFFFFFF) { 
+			u_handler_err(UE_READ_FILE);
+			return FALSE;
+		}
+    if ( num_bytes == 0 && len != 0 ) {
+			if ( !bd->flg_mess_eof ) u_handler_err(UE_END_OFF_FILE);
+      return 0;
+    }
+		bd->cur_buf = 0;
+		len -= lentmp;
+		cur_data += lentmp;
+		bd->len_buf = num_bytes;
+	}
+	return rezult;
+}
+
+WORD load_str(lpBUFFER_DAT bd, WORD len, char * data)
+{
+	register WORD lentmp, rezult, cur_data;
+	short num_bytes, flg_eos = 0;
+	char  *pdata, * ptmp;
+
+	rezult = 0;
+	pdata = (char *)data;
+	cur_data = 0;
+	if ( bd->flg_no_read ) data = NULL;
+
+//	len--;			//    ( 26.01.98)
+	len--;			//   
+	while (len) {
+		if ( len + bd->cur_buf <= bd->len_buf) {
+			ptmp = (char*)memchr(&bd->buf[bd->cur_buf], '\n', len);
+			if ( ptmp ) {
+				flg_eos = 1;
+				len = (WORD)(ptmp - &bd->buf[bd->cur_buf]) + 1;
+			}
+m_read:
+			if ( data ) memcpy(&pdata[cur_data],&bd->buf[bd->cur_buf],len);
+			rezult += len;
+			bd->cur_buf += len;
+			break;
+		}
+		if ( bd->len_buf <= bd->cur_buf ) {
+			lentmp = 0;
+			goto m;
+		}
+		lentmp = bd->len_buf - bd->cur_buf;
+		ptmp = (char*)memchr(&bd->buf[bd->cur_buf], '\n', lentmp);
+		if ( ptmp ) {
+			flg_eos = 1;
+			len = (WORD)(ptmp - &bd->buf[bd->cur_buf]) + 1;
+			goto m_read;
+		}
+		if ( data ) memcpy(&pdata[cur_data],&bd->buf[bd->cur_buf],lentmp);
+		rezult += lentmp;
+m:
+		if ( !flush_buf(bd) ) return FALSE;
+		if (lentmp) bd->p_beg += bd->len_buf;
+		else        bd->p_beg += bd->cur_buf;
+		if (nb_lseek(bd->handle,bd->p_beg,SEEK_SET) == 0xFFFFFFFF) return FALSE;
+		if ( (num_bytes = (short)nb_read(bd->handle,bd->buf,SIZE_VPAGE)) == 0xFFFFFFFF) { /*   */
+			u_handler_err(UE_READ_FILE);
+			return FALSE;
+		}
+		if ( num_bytes == 0 && len != 0 ) {
+			bd->cur_buf += rezult;
+			if ( rezult ) goto end;
+			if ( !bd->flg_mess_eof ) u_handler_err(UE_END_OFF_FILE);
+			return 0;
+		}
+		bd->cur_buf = 0;
+		len -= lentmp;
+		cur_data += lentmp;
+		bd->len_buf = num_bytes;
+	}
+end:
+	if ( flg_eos )
+	{
+		rezult -= 2;
+		if ( data[rezult] != 0x0D )
+			rezult++;
+	}
+	data[rezult] = 0;
+
+	bd->cur_line++;
+	return rezult+1;
+}
+
+
+BOOL flush_buf(lpBUFFER_DAT bd)
+{
+	if ( !bd->flg_modify ) return TRUE;
+
+	nb_lseek(bd->handle,bd->p_beg,SEEK_SET);
+  if (nb_write(bd->handle,bd->buf,bd->len_buf) != bd->len_buf) { /*   */
+		u_handler_err(UE_WRITE_FILE);
+		return FALSE;
+	}
+	bd->flg_modify = 0;
+	return TRUE;
+}
+BOOL seek_buf(lpBUFFER_DAT bd,int offset)
+{
+  if ( offset == -1 )  offset = bd->len_file;
+  if ( ! (bd->p_beg <= (ULONG)offset && offset <= (int)(bd->p_beg + (ULONG)bd->len_buf)  ) ) {
+		if ( !flush_buf(bd) ) return FALSE;
+		bd->p_beg = offset;
+    if (nb_lseek(bd->handle,offset,SEEK_SET) == 0xFFFFFFFF) {
+			u_handler_err(UE_SEEK_FILE);
+      return FALSE;
+    }
+		bd->len_buf = 0;
+	}
+	bd->cur_buf = (short)(offset - bd->p_beg);
+	return TRUE;
+}
+int get_buf_offset(lpBUFFER_DAT bd)
+{
+  return (bd->p_beg + bd->cur_buf );
+}
+BOOL close_buf(lpBUFFER_DAT bd)
+{
+	BOOL cod;
+
+	cod = flush_buf(bd);
+	SGFree(bd->buf);
+	if (!nb_close(bd->handle)) {
+		u_handler_err(UE_CLOSE_FILE);
+		cod = FALSE;
+	}
+	memset(bd,0,sizeof(BUFFER_DAT));  bd->handle = 0;
+	buf_level--;
+	return cod;
+}

CSG/sgCore/Core/O_UTIL/U_BUFSCN.cpp

@@ -0,0 +1,149 @@
+#include "../sg.h"
+
+
+static BOOL set_sb_buf_index(lpSB_INFO sbi);
+static BOOL set_sb_next_buf_string(lpSB_INFO sbi);
+static BOOL get_sb_next_var(lpSB_INFO sbi, short* type, void* value);
+
+BOOL init_scan_buf(lpSB_INFO sbi, char* name)
+{
+	if(!init_buf(&sbi->bd, name, BUF_OLD)) return FALSE;
+	sbi->lread = get_buf_offset(&sbi->bd);
+	sbi->buf[0] = 0;
+	sbi->index  = 0;
+	sbi->fprogon = TRUE;
+	return TRUE;
+}
+
+BOOL close_scan_buf(lpSB_INFO sbi)
+{
+	return close_buf(&sbi->bd);
+}
+
+static BOOL set_sb_buf_index(lpSB_INFO sbi)
+{
+	while(sbi->buf[sbi->index] == ' ' || sbi->buf[sbi->index] == 9)
+		sbi->index++;
+	if(sbi->buf[sbi->index] == ','){
+		if(sbi->fprogon) return FALSE;
+		sbi->index++;
+		while(sbi->buf[sbi->index] == ' ' || sbi->buf[sbi->index] == 9)
+			sbi->index++;
+	}
+	sbi->fprogon = FALSE;
+	return TRUE;
+}
+
+static BOOL set_sb_next_buf_string(lpSB_INFO sbi)
+{
+short l, i, lserv, lmax = C_MAX_STRING_CONSTANT;
+char  pk[3]  = {'\r','\n', '\r'};
+long  lnoread;
+
+	l = lmax + 2;
+	lnoread = sbi->bd.len_file - sbi->lread;
+	if(l > lnoread) l = (short)lnoread;
+	if(!seek_buf(&sbi->bd, sbi->lread))       return FALSE;
+	if(load_data(&sbi->bd, l, sbi->buf) != l) return FALSE;
+	lserv = 0;
+	for(i = 0; i < l; i++){
+		if(sbi->buf[i] == 9) sbi->buf[i] = ' ';
+		if(l - i >= 2){
+			if(!memcmp(&sbi->buf[i], pk, 2) || !memcmp(&sbi->buf[i], &pk[1], 2)){
+				lserv = 2;
+				break;
+			}
+		}
+		if(sbi->buf[i] == pk[0] || sbi->buf[i] == pk[1]) {
+			lserv = 1;
+			break;
+		}
+	}
+	if(i > lmax) i = lmax;
+	sbi->buf[i] = 0;
+	sbi->lread += (strlen(sbi->buf) + lserv);
+	sbi->index = 0;
+	sbi->fprogon = TRUE;
+	return TRUE;
+}
+
+static BOOL get_sb_next_var(lpSB_INFO sbi, short* type, void* value)
+{
+/*UC_RESULT cres;
+ULONG     rlen;
+long      lnoread;
+
+
+	while(TRUE){
+		if(!set_sb_buf_index(sbi)) return FALSE;
+		if(!sbi->buf[sbi->index]){
+			lnoread = sbi->bd.len_file - sbi->lread;
+			if(!lnoread) return FALSE;
+			if(!set_sb_next_buf_string(sbi)) return FALSE;
+			continue;
+		}
+		if(!uc_calc_express(sbi->buf, &sbi->index, FALSE, FALSE, &cres, &rlen, value))
+			return FALSE;
+		if(cres.status != UC_NORMAL)
+			return FALSE;
+		if((cres.type != UC_NUM) && (cres.type != UC_STRING))
+			return FALSE;
+		*type = cres.type;
+		return TRUE;
+	}*/return FALSE;
+}
+
+
+BOOL get_sb_sgFloat(lpSB_INFO sbi, BOOL poz, sgFloat *num)
+{
+/*short type;
+	if(!get_sb_next_var(sbi, &type, &gs_result.r)) return FALSE;
+	if(type != UC_NUM) return FALSE;
+	if(poz && gs_result.r.d <= 0.) return FALSE;
+	*num = gs_result.r.d;
+	return TRUE;*/return FALSE;
+}
+
+BOOL get_sb_int(lpSB_INFO sbi, BOOL poz, short *num)
+{
+/*short type;
+	if(!get_sb_next_var(sbi, &type, &gs_result.r)) return FALSE;
+	if(type != UC_NUM) return FALSE;
+	if(poz && gs_result.r.d <= 0.) return FALSE;
+	if(fabs(gs_result.r.d) > (sgFloat)(MAXSHORT)) return FALSE;
+	*num = (short)gs_result.r.d;
+	return TRUE;*/return FALSE;
+}
+
+BOOL get_sb_long(lpSB_INFO sbi, BOOL poz, int *num)
+{
+/*short type;
+	if(!get_sb_next_var(sbi, &type, &gs_result.r)) return FALSE;
+	if(type != UC_NUM) return FALSE;
+	if(poz && gs_result.r.d <= 0.) return FALSE;
+	if(fabs(gs_result.r.d) > (sgFloat)(MAXLONG)) return FALSE;
+	*num = (int)gs_result.r.d;
+	return TRUE;*/return FALSE;
+}
+
+BOOL get_sb_text(lpSB_INFO sbi, BOOL empty)
+{
+/*short type;
+	if(!get_sb_next_var(sbi, &type, &gs_result.r)) return FALSE;
+	if(type != UC_STRING) return FALSE;
+	if(!empty && strlen(gs_lex) == 0) return FALSE;
+	return TRUE;*/return FALSE;
+}
+
+BOOL fc_assign_curr_ident(hOBJ hobj)
+//        
+//   
+{
+lpOBJ obj;
+
+//  if(!uc_assign_curr_ident(UC_hOBJ, &hobj)) return FALSE;
+  obj = (lpOBJ)hobj;
+	obj->status |= ST_IDENT;
+	return TRUE;
+}
+

CSG/sgCore/Core/O_UTIL/U_DIMVIR.cpp

@@ -0,0 +1,415 @@
+#include "../sg.h"
+//#include <o_util.h>
+
+static  VADR alloc_page(void);
+static  BOOL add_dim_page(lpVDIM dim);
+static  VADR get_hpage(lpVDIM dim, short num_page);
+
+BOOL init_vdim(lpVDIM dim, short size_elem)
+{
+  memset(dim,0,sizeof(VDIM));
+  dim->num_elem_page = SIZE_VPAGE/size_elem;
+  dim->size_elem     = size_elem;
+	return TRUE;
+}
+
+BOOL add_elem(lpVDIM dim,void * buf)
+{
+	short num;
+	short num_page;
+	char * p;
+  VADR  hpage;
+
+	num = (short)(dim->num_elem %  dim->num_elem_page);
+	if ( !num )
+		if ( !add_dim_page(dim) ) return FALSE;
+	num_page = (short)(dim->num_elem / dim->num_elem_page);
+	hpage = get_hpage(dim,num_page);
+  p   = (char *)hpage + num*dim->size_elem;
+  if(buf)
+	  memcpy(p,buf,dim->size_elem);
+  else
+	  memset(p,0,dim->size_elem);
+	dim->num_elem++;
+	return TRUE;
+}
+
+BOOL add_dim_elem(lpVDIM dim,void * buf,short number)
+{
+  short num,num_page,num_tmp;
+	char * p;
+  VADR      hpage;
+
+once:
+	num = (short)(dim->num_elem %  dim->num_elem_page);
+	num_page = (short)(dim->num_elem / dim->num_elem_page);
+  if ( !num )  if ( !add_dim_page(dim) ) return FALSE;
+	hpage = get_hpage(dim,num_page);
+  p   = (char *)hpage + num*dim->size_elem;
+  num_tmp =  dim->num_elem_page - num - number;
+  if ( num_tmp > number ) num_tmp = number;
+	memcpy(p,buf,dim->size_elem*num_tmp);
+  number -= num_tmp;
+  dim->num_elem += num_tmp;
+  if ( number ) {
+    reinterpret_cast<char * &>(buf) += num_tmp*dim->size_elem;
+//nb     num = 0;
+    goto once;
+  }
+	return TRUE;
+}
+
+BOOL read_dim_elem(lpVDIM dim,int num,void * buf,short number)
+{
+	short num_page,num_tmp;
+	char * p;
+	VADR  hpage;
+
+once:
+	num  %= dim->num_elem_page;
+	num_page = (short)(dim->num_elem / dim->num_elem_page);
+	hpage = get_hpage(dim,num_page);
+	p   = (char *)hpage + (short)(num)*dim->size_elem;
+	num_tmp =  dim->num_elem_page - (short)num - number;
+  if ( num_tmp > number ) num_tmp = number;
+  memcpy(p,buf,dim->size_elem*num_tmp);
+  number -= num_tmp;
+  dim->num_elem += num_tmp;
+  if ( number ) {
+    reinterpret_cast<char * &>(buf) += num_tmp*dim->size_elem;
+    num = 0;
+    goto once;
+  }
+	return TRUE;
+}
+BOOL write_elem(lpVDIM dim,int num, void * data)
+{
+	short num_page;
+	char * p;
+	VADR  hpage;
+
+	if ( num >= dim->num_elem ) return FALSE;
+	num_page = (short)(num / dim->num_elem_page);
+	num     %= dim->num_elem_page;
+	hpage = get_hpage(dim,num_page);
+	p = (char *)hpage + (short)(num)*dim->size_elem;
+  if(data)
+	  memcpy(p,data,dim->size_elem);
+  else
+	  memset(p,0,dim->size_elem);
+	return TRUE;
+}
+void * get_elem(lpVDIM dim, int num)
+{
+	short num_page;
+	char  *p;
+	VADR  hpage;
+
+	if ( num >= dim->num_elem ) return NULL;
+	num_page = (short)(num / dim->num_elem_page);
+	num     %= dim->num_elem_page;
+	hpage = get_hpage(dim,num_page);
+	p = (char *)hpage;
+	return ( p + (short)num*dim->size_elem);
+}
+
+BOOL begin_rw(lpVDIM dim, int num)
+{
+	dim->elem       = NULL;
+	dim->cur_elem   = num;
+	return TRUE;
+}
+
+void * get_next_elem(lpVDIM dim)
+{
+	short num, num_page;
+
+  if ( dim->cur_elem >= dim->num_elem )  goto err;
+	if ( !(dim->cur_elem % dim->num_elem_page) || !dim->elem) {
+		num_page = (short)(dim->cur_elem / dim->num_elem_page);
+		num      = (short)(dim->cur_elem % dim->num_elem_page);
+		dim->hpagerw = get_hpage(dim,num_page);
+    if ( !dim->hpagerw ) goto err;
+		dim->elem = (char *)dim->hpagerw;
+        dim->elem += num*dim->size_elem;
+		goto m;
+	}
+    dim->elem += dim->size_elem;
+m:
+	dim->cur_elem++;
+	return dim->elem;
+err:
+  end_rw(dim);
+  return NULL;
+}
+void end_rw(lpVDIM dim)
+{
+	dim->elem = NULL;
+}
+BOOL read_elem(lpVDIM dim, int num, void * buf)
+{
+	short num_page;
+	char * p;
+	VADR  hpage;
+
+	if ( num >= dim->num_elem ) return FALSE;
+	num_page = (short)(num / dim->num_elem_page);
+	num     %= dim->num_elem_page;
+	hpage = get_hpage(dim,num_page);
+	p = (char *)hpage + (short)(num)*dim->size_elem;
+	memcpy(buf,p,dim->size_elem);
+	return TRUE;
+}
+void free_vdim(lpVDIM dim)
+{
+  delete_elem_list(dim,0L);
+	memset(dim,0,sizeof(VDIM));
+}
+static  BOOL add_dim_page(lpVDIM dim)
+{
+	VADR hpage;
+	VADR * p;
+	short num_page;
+
+	num_page = (short)(dim->num_elem / dim->num_elem_page);
+	if ( (hpage = alloc_page()) == NULL ) return FALSE;
+	if ( num_page < NUM_VDIM_PAGE ) {
+		dim->page[num_page] = hpage;
+		return TRUE;
+	}
+	if ( !dim->hpage_a )  {  //   
+		if ( (dim->hpage_a = alloc_page()) == NULL ) goto err;
+	}
+	num_page -= NUM_VDIM_PAGE;
+	if ( num_page >= SIZE_VPAGE/sizeof(VADR) ) {
+		u_handler_err(UE_OVERFLOW_VDIM);
+		return FALSE;
+	}
+	p = (VADR*)dim->hpage_a;
+	p[num_page] = hpage;
+	return TRUE;
+err:
+	SGFree(hpage);
+	return FALSE;
+}
+static  VADR alloc_page(void)
+{
+	void * p;
+	VADR			hpage;
+
+	if ( (hpage = SGMalloc(SIZE_VPAGE)) == NULL ) return NULL;
+	p = (void*)hpage;
+	memset(p, 0, SIZE_VPAGE);
+	return hpage;
+}
+static  VADR get_hpage(lpVDIM dim, short num_page)
+{
+  if ( num_page < NUM_VDIM_PAGE ) return ( dim->page[num_page] );
+  else {
+		VADR hpage;
+		VADR * pa;
+    num_page -= NUM_VDIM_PAGE;
+    pa = (VADR*)dim->hpage_a;
+    hpage = pa[num_page];
+		return hpage;
+  }
+}
+BOOL find_elem(lpVDIM dim,int *num_first,
+      BOOL (*func)(void * elem, void * user_data), void * user_data)
+{
+  void * elem;
+  if ( !begin_rw( dim, *num_first) ) return FALSE;
+	while ( (elem=get_next_elem(dim)) != NULL ) {
+    if ( !func(elem, user_data) ) continue;
+    *num_first = dim->cur_elem - 1;
+    end_rw(dim);
+    return TRUE;
+  }
+  end_rw(dim);
+  return FALSE;
+}
+
+void delete_elem_list(lpVDIM dim,int number)
+{
+	short   i, num_page;
+
+	if ( number >= dim->num_elem )  return;
+	num_page = (short)(number / dim->num_elem_page);
+
+
+	if ( number % dim->num_elem_page )   num_page++;
+	for ( i=num_page; i<NUM_VDIM_PAGE; i++) {
+		if ( !dim->page[i] ) break;
+		SGFree(dim->page[i]);
+		dim->page[i] = NULL;
+	}
+	if ( dim->hpage_a ) {
+		VADR * pa;
+		num_page = (short)(dim->num_elem / dim->num_elem_page + 1);
+		num_page -=NUM_VDIM_PAGE;
+		pa = (VADR *)dim->hpage_a;
+		for ( i=0; i<num_page; i++) {
+			if ( !pa[i] ) continue;
+			SGFree(pa[i]);
+			pa[i] = NULL;
+		}
+		SGFree(dim->hpage_a);
+    dim->hpage_a = NULL;
+	}
+	dim->num_elem = number;
+}
+
+
+typedef struct {
+	VADR			hpage;
+	int				ind;
+	int				ind_max;
+	void *	data;
+}SORT_ELEM;
+
+BOOL	sort_vdim(lpVDIM vdim, VDFCMP func)
+//BOOL sort_vdim(lpVDIM vdim,short (*func)(const void * elem1,
+//																				const void * elem2))
+{
+	short   i,j,num_page,num_elem_last, tmp, num_page1;
+	char	* p;
+	SORT_ELEM* fe;
+	VDIM	vd_new;
+	VADR * pa;
+
+	if (vdim->num_elem == 0) return TRUE;
+	num_page = (short)(vdim->num_elem / vdim->num_elem_page);
+	num_elem_last = (short)(vdim->num_elem % vdim->num_elem_page);
+	if ( num_page < NUM_VDIM_PAGE )	tmp = num_page;
+	else														tmp = NUM_VDIM_PAGE;
+	for ( i= 0; i<tmp; i++) {
+		if ( !vdim->page[i] ) return FALSE;
+		p = (char*)vdim->page[i];
+		qsort(p,vdim->num_elem_page,vdim->size_elem,func);
+	}
+	if ( num_elem_last && tmp < NUM_VDIM_PAGE) {
+		p = (char*)vdim->page[i];
+		qsort(p,num_elem_last,vdim->size_elem,func);
+		goto m_merge;
+	}
+	if ( vdim->hpage_a ) {
+		num_page1 = num_page - NUM_VDIM_PAGE;
+		pa = (VADR*)vdim->hpage_a;
+		for ( i=0; i<num_page1; i++) {
+			if ( !pa[i] ) continue;
+			p = (char*)pa[i];
+			qsort(p,vdim->num_elem_page,vdim->size_elem,func);
+		}
+		//   
+		if ( num_elem_last )  {
+			p = (char*)pa[i];
+			qsort(p,num_elem_last,vdim->size_elem,func);
+		}
+	}
+m_merge:  //   
+	if ( num_elem_last )	num_page++;
+	if ( num_page == 1 ) return TRUE;
+	if ( 0 ==(fe = (SORT_ELEM*)SGMalloc( num_page*(sizeof(SORT_ELEM)+vdim->size_elem))) )
+		return FALSE;
+	if ( num_page < NUM_VDIM_PAGE )	tmp = num_page;
+	else					 									tmp = NUM_VDIM_PAGE;
+	for ( i= 0; i<tmp; i++) {
+		fe[i].hpage = vdim->page[i];
+		fe[i].ind	  	= 0;
+		fe[i].ind_max	= vdim->num_elem_page;
+		fe[i].data		= (char*)&fe[num_page]+i*vdim->size_elem;
+		p = (char*)vdim->page[i];
+		memcpy(fe[i].data,p,vdim->size_elem);
+	}
+	if ( vdim->hpage_a ) {
+		j = i;
+		num_page1 = num_page - NUM_VDIM_PAGE;
+		pa = (VADR*)vdim->hpage_a;
+		for ( i=0; i<num_page1; i++,j++ ) {
+			p = (char*)pa[i];
+			fe[j].hpage		= pa[i];
+			fe[j].ind	  	= 0;
+			fe[j].ind_max	= vdim->num_elem_page;
+			fe[j].data		= (char*)&fe[num_page]+j*vdim->size_elem;
+			memcpy(fe[j].data,p,vdim->size_elem);
+		}
+	}
+	//   
+	if ( !num_elem_last ) fe[num_page-1].ind_max = vdim->num_elem_page;
+	else	fe[num_page-1].ind_max = (short)(vdim->num_elem % vdim->num_elem_page);
+	vd_new = *vdim;
+	if ( !init_vdim(&vd_new, vdim->size_elem)) goto err;
+
+	while (1) {
+		//   
+		for ( j=0; j< num_page; j++) {
+			if ( fe[j].ind == fe[j].ind_max ) continue;	//   
+			break;
+		}
+		if ( j == num_page ) break;  //  
+		tmp = j;
+		for ( i=j+1; i< num_page; i++) {
+			if ( fe[i].ind == fe[i].ind_max ) continue;	//   
+			if ( func(fe[tmp].data,fe[i].data) > 0 ) tmp = i;
+		}
+		if ( !add_elem(&vd_new,fe[tmp].data)) goto err;
+		fe[tmp].ind++;
+		if ( fe[tmp].ind == fe[tmp].ind_max ) continue;
+		p = (char*)fe[tmp].hpage;
+		memcpy(fe[tmp].data,p + fe[tmp].ind*vdim->size_elem, vdim->size_elem);
+	}
+	SGFree(fe);
+	free_vdim(vdim);
+	*vdim = vd_new;
+	return TRUE;
+err:
+	free_vdim(&vd_new);
+	SGFree(fe);
+	return FALSE;
+}
+
+int	bsearch_vdim(const void *key,lpVDIM vdim, VDFCMP func)
+{
+	short   i,num_page,num_elem_last, tmp;
+	char	* p, * p1;
+	VADR * pa;
+	int	ind = 0;
+
+	num_page = (short)(vdim->num_elem / vdim->num_elem_page);
+	num_elem_last = (short)(vdim->num_elem % vdim->num_elem_page);
+	if ( num_page < NUM_VDIM_PAGE )	tmp = num_page;
+	else														tmp = NUM_VDIM_PAGE;
+	for ( i= 0; i<tmp; i++,ind++) {
+		if ( !vdim->page[i] ) return FALSE;
+		p = (char*)vdim->page[i];
+		p1 = (char*)bsearch(key,p,vdim->num_elem_page,vdim->size_elem,func);
+		if ( p1 ) goto find1;
+	}
+	if ( num_elem_last && tmp < NUM_VDIM_PAGE) {
+		p = (char*)vdim->page[i];
+		p1 = (char*)bsearch(key,p,num_elem_last,vdim->size_elem,func);
+		if ( p1 ) goto find1;
+	}
+	if ( vdim->hpage_a ) {
+		num_page -= NUM_VDIM_PAGE;
+		pa = (VADR*)vdim->hpage_a;
+		for ( i=0; i<num_page; i++,ind++) {
+			if ( !pa[i] ) continue;
+			p = (char*)pa[i];
+			p1 = (char*)bsearch(key,p,vdim->num_elem_page,vdim->size_elem,func);
+			if ( p1 ) goto find1;
+		}
+		//    
+		if ( num_elem_last )  {
+			p = (char*)pa[i];
+			p1 = (char*)bsearch(key,p,num_elem_last,vdim->size_elem,func);
+			if ( p1 ) goto find1;
+		}
+	}
+	return -1;
+find1:
+	ind *= vdim->num_elem_page;
+	ind += (p1 - p)/ vdim->size_elem;
+	return ind;
+}
+

CSG/sgCore/Core/O_UTIL/U_DTT.cpp

@@ -0,0 +1,217 @@
+#include "../sg.h"
+
+void (*u_ted_exit)  (void) = NULL;
+
+BOOL ted_text_init(lpDTED_TEXT dtt, short max_line)
+    
+{
+char *m;
+
+	memset(dtt, 0, sizeof(DTED_TEXT));
+	//     
+	if(0 ==(m = (char*)SGMalloc(sizeof(VDIM)    +
+									sizeof(VLD)))) return FALSE;
+
+	dtt->vd     = (lpVDIM)   (m);
+	dtt->vld    = (lpVLD)    (m + sizeof(VDIM));
+	init_vdim(dtt->vd, sizeof(DTED_STR));
+	init_vld(dtt->vld);
+	dtt->maxline = max_line;
+	return TRUE;
+}
+
+void static_text_init(lpDTED_TEXT dtt, short max_line)
+  
+{
+	init_vdim(dtt->vd, sizeof(DTED_STR));
+	init_vld(dtt->vld);
+	dtt->maxline   = max_line;
+	dtt->gmod_flag = 0;
+}
+
+void static_text_free(lpDTED_TEXT dtt)
+
+{
+	free_vdim(dtt->vd);
+	free_vld_data(dtt->vld);
+	init_vdim(dtt->vd, sizeof(DTED_STR));
+	init_vld(dtt->vld);
+	dtt->maxline   = 0;
+	dtt->gmod_flag = 0;
+}
+
+
+void ted_text_free(lpDTED_TEXT dtt)
+ 
+{
+	if(dtt->vd){
+		free_vdim(dtt->vd);
+		free_vld_data(dtt->vld);
+		SGFree(dtt->vd);
+	}
+	memset(dtt, 0, sizeof(DTED_TEXT));
+}
+
+
+BOOL ted_text_add(lpDTED_TEXT dtt, char *str)
+    
+{
+DTED_STR tstr;
+WORD     len;
+char     c = 0;
+BOOL     cod;
+short    imax = C_MAX_STRING_CONSTANT;
+
+	if(dtt->vd->num_elem > MAXSHORT - 100) return FALSE;
+	len = strlen(str);
+	if(len > imax) {
+		c = str[imax];
+		str[imax] = 0;
+		len = imax;
+	}
+	if(len > dtt->maxline)  dtt->maxline = len;
+	len++;
+	memset(&tstr, 0, sizeof(DTED_STR));
+	cod = add_data_to_avalue(dtt->vld, &tstr.v, len, str);
+	if(c) str[imax] = c;
+	if(!cod) return FALSE;
+	if(!add_elem(dtt->vd, &tstr))
+		return FALSE;
+	return TRUE;
+}
+
+void ted_load_str(void  *ted, IDENT_V id, char *str, WORD *len)
+{
+DTED_STR    tstr;
+lpDTED_TEXT dtt = (lpDTED_TEXT)ted;
+ULONG       llen; 
+
+	if(!read_elem(dtt->vd, id - 1, &tstr))         ted_exit();
+	if(!load_data_from_avalue(&tstr.v, &llen, str))  ted_exit();
+  *len = (WORD)llen;
+}
+
+IDENT_V ted_get_next_str(void  *ted, IDENT_V id, char *str)
+
+{
+DTED_STR    tstr;
+lpDTED_TEXT dtt = (lpDTED_TEXT)ted;
+ULONG       len;
+
+	if(!id){
+	 if(!dtt->vd->num_elem){
+		str[0] = 0;
+		return -1;
+	 }
+	 id = 1;
+	}
+	if(!read_elem(dtt->vd, id - 1, &tstr))          ted_exit();
+	if(!load_data_from_avalue(&tstr.v, &len, str))  ted_exit();
+	if(id >= dtt->vd->num_elem) id = 0;
+	else id++;
+	return id;
+}
+
+void ted_get_text_size(void  *ted, ULONG *numchar, int *numstr)
+  
+{
+DTED_STR    tstr;
+lpA_VALUE   av;
+lpDTED_TEXT dtt = (lpDTED_TEXT)ted;
+IDENT_V     id;
+
+	*numchar = 0;
+	av = &tstr.v;
+	for(id = 0; id < dtt->vd->num_elem; id++){
+		if(!read_elem(dtt->vd, id, &tstr))     ted_exit();
+		if(av->status == A_NOT_INLINE)
+			*numchar += (av->value.ni.len - 1);
+		else
+			*numchar += (av->status - 1);
+	}
+	*numstr = (int)dtt->vd->num_elem;
+	return;
+}
+
+BOOL create_dtt_by_file(lpBUFFER_DAT bd, lpDTED_TEXT dtt, BOOL dosflag, BOOL *trimflag)
+
+{
+char  buf[C_MAX_STRING_CONSTANT + 2];
+char  pk[3]  = {'\r','\n', '\r'};
+short l, i, lserv, lmax = C_MAX_STRING_CONSTANT;
+int   lread, lnoread, numchar;
+BOOL  trim;
+
+	trim = *trimflag;
+	*trimflag = FALSE;
+
+	l = lmax + 2;
+	lread = get_buf_offset(bd);
+
+	numchar = 0;
+	while((lnoread = bd->len_file - lread) > 0){
+		if(l > lnoread) l = (short)lnoread;
+		if(!seek_buf(bd, lread))       return FALSE;
+		if(load_data(bd, l, buf) != l) return FALSE;
+		lserv = 0;
+		for(i = 0; i < l; i++){
+			if(!buf[i] || ((UCHAR)buf[i]) == ML_S_C || buf[i] == 9) buf[i] = ' ';
+			if(l - i >= 2){
+				if(!memcmp(&buf[i], pk, 2) || !memcmp(&buf[i], &pk[1], 2)){
+					lserv = 2;
+					break;
+				}
+			}
+			if(buf[i] == pk[0] || buf[i] == pk[1]) {
+				lserv = 1;
+				break;
+			}
+		}
+		if(i > lmax) i = lmax;
+		buf[i] = 0;
+		lread += (strlen(buf) + lserv);
+		if(dosflag)
+			z_OemToAnsi(buf, buf, 0);
+		if(trim){
+			numchar += (strlen(buf) + 2);
+			if(numchar > TED_MAX_TEXT_LEN){
+				*trimflag = TRUE;
+				return TRUE;
+			}
+		}
+		if(!ted_text_add(dtt, buf)){
+			*trimflag = TRUE;
+			return TRUE;
+		}
+		continue;
+	}
+	return TRUE;
+}
+
+BOOL create_file_by_dtt(lpBUFFER_DAT bd, lpDTED_TEXT dtt, BOOL dosflag)
+
+{
+char    pk[2]  = {'\r','\n'};
+IDENT_V id = 0;
+ULONG   numchar;
+int     numstr;
+char    buf[C_MAX_STRING_CONSTANT + 1];
+
+	ted_get_text_size(dtt, &numchar, &numstr);
+	if(numstr){
+		do{
+			id = ted_get_next_str(dtt, id, buf);
+			if(dosflag)
+				z_AnsiToOem(buf, buf, 0);
+			if(!story_data(bd, strlen(buf), buf)) return FALSE;
+			if(!story_data(bd, 2, pk))            return FALSE;
+		}while(id);
+	}
+	return TRUE;
+}
+
+void ted_exit(void){
+
+	if(u_ted_exit)  u_ted_exit();
+	exit(1);
+}

CSG/sgCore/Core/O_UTIL/U_ERR.cpp

@@ -0,0 +1,58 @@
+#include "../sg.h"
+
+void u_handler_err(short cod,...)
+{
+	char s[MAXPATH+80];
+	va_list ap;
+	char *  name;
+
+	strcpy(s,GetIDS(IDS_SG196)); //	 
+	switch (cod) {
+		case UE_OPEN_ACCES:
+			strcat(s,GetIDS(IDS_SG255));
+			break;
+		case UE_OPEN_EINVACC:
+			strcat(s,GetIDS(IDS_SG256));
+			break;
+		case UE_OPEN_EMFILE:
+			strcat(s,GetIDS(IDS_SG257));
+			break;
+		case UE_OPEN_ENOENT:
+			strcat(s,GetIDS(IDS_SG258));
+			break;
+
+		case UE_NO_VMEMORY:   //   
+			strcat(s,GetIDS(IDS_SG197));
+			break;
+		case UE_READ_FILE:    //     
+			strcpy(s,GetIDS(IDS_SG198));
+			break;
+		case UE_WRITE_FILE:    //      
+			strcpy(s,GetIDS(IDS_SG199));
+			break;
+		case UE_OPEN_FILE:     //    
+			va_start(ap, cod);
+			name = va_arg(ap,char *);
+			va_end(ap);
+			strcpy(s,GetIDS(IDS_SG200));
+			strncat(s,name,MAXPATH);
+			break;
+		case UE_OVERFLOW_VDIM:         //  VDIM
+			strcat(s,GetIDS(IDS_SG201));
+			break;
+		case UE_CLOSE_FILE:     //    
+			strcpy(s,GetIDS(IDS_SG202));
+			break;
+		case UE_END_OFF_FILE:     //   
+			strcat(s,GetIDS(IDS_SG203));
+			break;
+		case UE_SEEK_FILE:     //   
+			strcat(s,GetIDS(IDS_SG204));
+			break;
+		default:
+			strcat(s,GetIDS(IDS_SG205));
+			//itoa(cod,&s[strlen(s)],10);
+			break;
+	}
+  put_message(EMPTY_MSG, s, 0);
+}

CSG/sgCore/Core/O_UTIL/U_ILIST.cpp

@@ -0,0 +1,257 @@
+#include "../sg.h"
+
+void il_init_listh(lpI_LISTH ilisth)
+{
+  memset(ilisth, 0, sizeof(I_LISTH));
+}
+
+BOOL il_attach_item_tail(lpVDIM vd, lpI_LISTH ilisth, IDENT_V item)
+{
+lpI_LIST  l;
+
+  if(ilisth->tail) {  //    
+	if(0 ==(l = (lpI_LIST)get_elem(vd, ilisth->tail - 1))) return FALSE;
+    l->next = item;
+  } else {
+    ilisth->head = item;
+  }
+  if(0 ==(l = (lpI_LIST)get_elem(vd, item - 1))) return FALSE;
+  l->prev = ilisth->tail;
+  l->next = 0;
+  ilisth->tail = item;
+  ilisth->num++;
+  return TRUE;
+}
+
+BOOL il_attach_item_head(lpVDIM vd, lpI_LISTH ilisth, IDENT_V item)
+{
+  if(!ilisth->head)  //   
+    return il_attach_item_tail(vd, ilisth, item);
+  return il_attach_item_befo(vd, ilisth, ilisth->head, item);
+}
+
+BOOL il_attach_item_befo(lpVDIM vd, lpI_LISTH ilisth, IDENT_V bitem,
+                         IDENT_V item)
+{
+lpI_LIST  l;
+IDENT_V   prev;
+
+  if(!bitem)
+    return il_attach_item_tail(vd, ilisth, item);
+
+  if(0 ==(l = (lpI_LIST)get_elem(vd, bitem - 1))) return FALSE;
+  prev = l->prev;
+  l->prev = item;
+  if(0 ==(l = (lpI_LIST)get_elem(vd, item - 1))) return FALSE;
+  l->prev = prev;
+  l->next = bitem;
+  if(prev){
+	if(0 ==(l = (lpI_LIST)get_elem(vd, prev - 1))) return FALSE;
+    l->next = item;
+  }
+  else
+		ilisth->head = item;
+
+	ilisth->num++;
+	return TRUE;
+}
+
+BOOL il_attach_list_befo(lpVDIM vd, lpI_LISTH ilisth, IDENT_V bitem,
+                         lpI_LISTH ilisthins)
+{
+lpI_LIST  l;
+IDENT_V   next, prev;
+
+  if(!ilisthins->num) return TRUE; //   
+  if(!il_break(vd, ilisthins, 0)) return FALSE; // 
+
+  if(!bitem){
+    if(ilisth->tail) {  //    
+	  if(0 ==(l = (lpI_LIST)get_elem(vd, ilisth->tail - 1))) return FALSE;
+      next = l->next;
+      l->next = ilisthins->head;
+      if(next){
+		if(0 ==(l = (lpI_LIST)get_elem(vd, next - 1))) return FALSE;
+        l->prev = ilisthins->tail;
+		if(0 ==(l = (lpI_LIST)get_elem(vd, ilisthins->tail - 1))) return FALSE;
+        l->next = next;
+      }
+      else {
+        ilisth->tail = ilisthins->tail;
+      }
+      ilisth->num += ilisthins->num;
+    }
+    else{
+      *ilisth = *ilisthins;
+    }
+    return TRUE;
+  }
+
+  if(0 ==(l = (lpI_LIST)get_elem(vd, bitem - 1))) return FALSE;
+  prev = l->prev;
+  l->prev = ilisthins->tail;
+  if(0 ==(l = (lpI_LIST)get_elem(vd, ilisthins->tail - 1))) return FALSE;
+  l->next = bitem;
+  if(prev){
+	if(0 ==(l = (lpI_LIST)get_elem(vd, prev - 1))) return FALSE;
+    l->next = ilisthins->head;
+	if(0 ==(l = (lpI_LIST)get_elem(vd, ilisthins->head - 1))) return FALSE;
+    l->prev = prev;
+  }
+  else
+    ilisth->head = ilisthins->head;
+
+  ilisth->num += ilisthins->num;
+	return TRUE;
+}
+
+BOOL il_close(lpVDIM vd, lpI_LISTH ilisth)
+{
+lpI_LIST  l;
+
+	if(ilisth->head == ilisth->tail) return TRUE; //    
+
+	if(0 ==(l = (lpI_LIST)get_elem(vd, ilisth->head - 1))) return FALSE;
+	l->prev = ilisth->tail;
+	if(0 ==(l = (lpI_LIST)get_elem(vd, ilisth->tail - 1))) return FALSE;
+	l->next = ilisth->head;
+	ilisth->tail = ilisth->head;
+
+	return TRUE;
+}
+
+BOOL il_break(lpVDIM vd, lpI_LISTH ilisth, IDENT_V item)
+{
+lpI_LIST  l;
+IDENT_V   prev;
+
+  //    
+	if(ilisth->head != ilisth->tail || ilisth->num <= 1) return TRUE;
+  if(!item) item = ilisth->head;
+  if(item < 0)
+    if(!il_get_next_item(vd, -item, &item)) return FALSE;
+
+  if(0 ==(l = (lpI_LIST)get_elem(vd, item - 1))) return FALSE;
+  prev = l->prev;
+  l->prev = 0;
+  if(0 ==(l = (lpI_LIST)get_elem(vd, prev - 1))) return FALSE;
+  l->next = 0;
+  ilisth->head = item;
+  ilisth->tail = prev;
+
+	return TRUE;
+}
+
+BOOL il_get_next_item(lpVDIM vd, IDENT_V item, lpIDENT_V next)
+{
+lpI_LIST l;
+
+  if(0 ==(l = (lpI_LIST)get_elem(vd, item - 1))) return FALSE;
+  *next = l->next;
+  return TRUE;
+}
+
+BOOL il_get_prev_item(lpVDIM vd, IDENT_V item, lpIDENT_V prev)
+{
+lpI_LIST l;
+
+  if(0 ==(l = (lpI_LIST)get_elem(vd, item - 1))) return FALSE;
+  *prev = l->prev;
+	return TRUE;
+}
+
+BOOL il_detach_item(lpVDIM vd, lpI_LISTH ilisth, IDENT_V item)
+{
+lpI_LIST l;
+IDENT_V  prev, next;
+BOOL     flclose;
+
+	flclose = (ilisth->num > 1 && ilisth->head == ilisth->tail);
+	if(0 ==(l = (lpI_LIST)get_elem(vd, item - 1))) return FALSE;
+	prev = l->prev;
+	next = l->next;
+	if(flclose && (ilisth->head == item))
+		ilisth->head = ilisth->tail = next;
+
+	if(next) {
+		if(0 ==(l = (lpI_LIST)get_elem(vd, next - 1))) return FALSE;
+		l->prev = prev;
+	}
+	if(prev) {
+		if(0 ==(l = (lpI_LIST)get_elem(vd, prev - 1))) return FALSE;
+		l->next = next;
+	} else {
+		if(ilisth->head != item ) return TRUE;  //   
+		ilisth->head = next;
+	}
+	if(!next) ilisth->tail = prev;
+	ilisth->num--;
+	if(flclose && ilisth->num == 1){ //     
+		if(0 ==(l = (lpI_LIST)get_elem(vd, ilisth->head - 1))) return FALSE;
+		l->prev = l->next = 0;
+	}
+	return TRUE;
+}
+
+BOOL il_add_elem(lpVDIM vd, lpI_LISTH filisth, lpI_LISTH ilisth,
+								 void  *value, IDENT_V bitem, lpIDENT_V item)
+{
+IDENT_V id;
+
+	id = filisth->head;
+	*item = -id;
+	if(!id){
+		//       -  
+		if(!add_elem(vd, value))               return FALSE;
+		id = vd->num_elem;
+		*item = -id;
+	}
+	else{
+		if(!il_detach_item(vd, filisth, id))  return FALSE;
+		if(!write_elem(vd, id - 1, value))     return FALSE;
+	}
+  //   
+  if(!il_attach_item_befo(vd, ilisth, bitem, id)) return FALSE;
+  *item = id;
+  return TRUE;
+}
+
+
+BOOL GetIndexByID(lpI_LISTH pIListh, lpVDIM pVd, IDENT_V id, long *index)
+{
+long    i = 0;
+IDENT_V idw;
+
+  idw = pIListh->head;
+  while(idw){
+    if(idw == id){
+      *index = i;
+      return TRUE;
+    }
+    if(!il_get_next_item(pVd, idw, &idw))
+      return FALSE;
+    i++;
+  }
+  return FALSE;
+}
+
+BOOL GetIDByIndex(lpI_LISTH pIListh, lpVDIM pVd, long index, IDENT_V* id)
+{
+long    i = 0;
+IDENT_V idw;
+
+  if(index < 0)
+    return FALSE;
+  idw = pIListh->head;
+  while(i < index){
+    if(!idw)
+      return FALSE;
+    if(!il_get_next_item(pVd, idw, &idw))
+      return FALSE;
+    i++;
+  }
+  *id = idw;
+  return TRUE;
+}
+
+

CSG/sgCore/Core/O_UTIL/U_LIST.cpp

@@ -0,0 +1,302 @@
+#include "../sg.h"
+
+static NUM_LIST  LIST_ZUDINA = OBJ_LIST;
+
+void copy_data(VADR dist,VADR source,WORD size)
+{
+  memcpy(dist, source, size);
+}
+
+void init_listh(lpLISTH listh)
+{
+  memset(listh,0,sizeof(LISTH));
+}
+
+void free_item_list(lpLISTH listh)
+{
+	free_tail_list_cur( listh, listh->hhead);
+}
+
+void free_tail_list(lpLISTH listh,VADR hpage)
+{
+	if ( hpage ) {
+		get_next_item(hpage,&hpage);
+		free_tail_list_cur( listh, hpage);
+	}
+}
+
+void free_tail_list_cur(lpLISTH listh,VADR hpage)
+{
+	lpLIST lplist;
+	VADR hnext,hprev;
+
+  if ( !hpage ) return;
+	get_prev_item(hpage,&hprev);
+	if ( hprev) {
+  	lplist = (lpLIST)hprev;
+		lplist->hnext = NULL;
+	} else
+		listh->hhead = NULL;
+	listh->htail = hprev;
+	while (hpage) {
+		lplist = (lpLIST)hpage;
+		hnext = lplist->hnext;
+		SGFree(hpage);
+		hpage = hnext;
+		listh->num--;
+	}
+}
+
+WORD free_intermediate_list(lpLISTH listh, VADR hpage_beg, VADR hpage_end)
+{
+	lpLIST  	lplist;
+	VADR 			hnext, hpage;
+	WORD	    count;
+
+	if ( hpage_beg == hpage_end ) return 0;
+	lplist = (lpLIST)hpage_beg;
+	hnext = lplist->hnext;
+	if ( hnext == hpage_end ) return 0;
+
+	hpage = hnext;
+	count = (WORD)listh->num;
+	while (hpage != hpage_end) {
+		lplist = (lpLIST)hpage;
+		hnext = lplist->hnext;
+		SGFree(hpage);
+		hpage = hnext;
+		listh->num--;
+	}
+  lplist = (lpLIST)hpage_beg;
+  lplist->hnext = hpage_end;
+
+  lplist = (lpLIST)hpage_end;
+  lplist->hprev = hpage_beg;
+	return (count - (WORD)listh->num);
+}
+
+void   RecursiveAddChildrenToSceneTree(lpOBJ lpO)
+{
+	ISceneTreeControl::TREENODEHANDLE  tr_hndl = lpO->handle_of_tree_node;
+	if (tr_hndl==NULL)
+		return;
+
+	hOBJ  list_elem = NULL;
+	if (lpO->type==OGROUP)
+		list_elem = ((lpGEO_GROUP)lpO->geo_data)->listh.hhead;
+	else
+		if (lpO->type==OPATH)
+			list_elem = ((lpGEO_PATH)lpO->geo_data)->listh.hhead;
+		else
+		{
+			assert(0);
+			return;
+		}
+
+	while (list_elem) 
+	{
+		lpOBJ curlpO = (lpOBJ)list_elem;
+		curlpO->handle_of_tree_node = 
+			application_interface->GetSceneTreeControl()->AddNode(&curlpO->extendedClass,tr_hndl);
+		if (curlpO->type==OPATH || curlpO->type==OGROUP)
+		{
+			RecursiveAddChildrenToSceneTree(curlpO);
+		}
+		get_next_item(list_elem,&list_elem);
+	}
+}
+
+void attach_item_head(lpLISTH listh,VADR hitem)
+{
+	if (listh==&objects)
+	{
+		lpOBJ lpO = (lpOBJ)hitem;
+		if (lpO->isAttachedToScene)
+			return;
+	}
+
+  lpLIST    l;
+
+  if ( listh->hhead ) {  //  
+    l = (lpLIST)listh->hhead;
+		if ( LIST_ZUDINA ) l += LIST_ZUDINA;
+    l->hprev = hitem;
+  } else {
+    listh->htail = hitem;
+  }
+  l = (lpLIST)hitem;
+	if ( LIST_ZUDINA ) l += LIST_ZUDINA;
+  l->hnext = listh->hhead;
+  l->hprev = NULL;
+  listh->hhead = hitem;
+	listh->num++;
+
+  if (listh==&objects)
+  {
+	  lpOBJ lpO = (lpOBJ)hitem;
+	  lpO->isAttachedToScene = true;
+	  if (application_interface && 
+		  application_interface->GetSceneTreeControl())
+	  {
+		  if (!application_interface->GetSceneTreeControl()->ShowNode(lpO->extendedClass))
+		  {
+			lpO->handle_of_tree_node = 
+				application_interface->GetSceneTreeControl()->AddNode(&lpO->extendedClass,NULL);
+			if (lpO->type==OPATH || lpO->type==OGROUP)
+			{
+				RecursiveAddChildrenToSceneTree(lpO);
+			}
+		  }
+	  }
+  }
+}
+
+void attach_item_tail(lpLISTH listh,VADR hitem)
+{
+	if (listh==&objects)
+	{
+		lpOBJ lpO = (lpOBJ)hitem;
+		if (lpO->isAttachedToScene)
+			return;
+	}
+
+  lpLIST    l;
+
+  if ( listh->htail ) {  //    
+    l = (lpLIST)listh->htail;
+		if ( LIST_ZUDINA ) l += LIST_ZUDINA;
+    l->hnext = hitem;
+  } else {
+    listh->hhead = hitem;
+  }
+  l = (lpLIST)hitem;
+	if ( LIST_ZUDINA ) l += LIST_ZUDINA;
+  l->hprev = listh->htail;
+  l->hnext = NULL;
+  listh->htail = hitem;
+	listh->num++;
+
+	if (listh==&objects)
+	{
+		lpOBJ lpO = (lpOBJ)hitem;
+		lpO->isAttachedToScene = true;
+		if (application_interface && 
+			application_interface->GetSceneTreeControl())
+		{
+			if (!application_interface->GetSceneTreeControl()->ShowNode(lpO->extendedClass))
+			{
+				lpO->handle_of_tree_node = 
+					application_interface->GetSceneTreeControl()->AddNode(&lpO->extendedClass,NULL);
+				if (lpO->type==OPATH || lpO->type==OGROUP)
+				{
+					RecursiveAddChildrenToSceneTree(lpO);
+				}
+			}
+		}
+	}
+}
+
+void get_next_item(VADR hitem,VADR * hnext)
+{
+  lpLIST l;
+
+  l = (lpLIST)hitem;
+	if ( LIST_ZUDINA ) l += LIST_ZUDINA;
+  *hnext = l->hnext;
+}
+
+void get_prev_item(VADR hitem,VADR * hprev)
+{
+  lpLIST l;
+
+  l = (lpLIST)hitem;
+	if ( LIST_ZUDINA ) l += LIST_ZUDINA;
+  *hprev = l->hprev;
+}
+
+void detach_item(lpLISTH listh,VADR hitem)
+{
+	if (listh==&objects)
+	{
+		lpOBJ lpO = (lpOBJ)hitem;
+		if (!lpO->isAttachedToScene)
+			return;
+	}
+
+  lpLIST l;
+  VADR hprev,hnext;
+
+  l = (lpLIST)hitem;
+	if ( LIST_ZUDINA ) l += LIST_ZUDINA;
+  hprev = l->hprev;
+  hnext = l->hnext;
+
+  if ( hnext ) {
+    l = (lpLIST)hnext;
+		if ( LIST_ZUDINA ) l += LIST_ZUDINA;
+    l->hprev = hprev;
+  }
+  if ( hprev ) {
+    l = (lpLIST)hprev;
+		if ( LIST_ZUDINA ) l += LIST_ZUDINA;
+    l->hnext = hnext;
+  } else {
+    if ( listh->hhead != hitem ) return;  //   
+    listh->hhead = hnext;
+  }
+  if ( !hnext ) listh->htail = hprev;
+	listh->num--;
+	
+	if (listh==&objects)
+	{
+		lpOBJ lpO = (lpOBJ)hitem;
+		lpO->isAttachedToScene = false;
+		if (application_interface && application_interface->GetSceneTreeControl())
+		{
+			if (lpO->handle_of_tree_node)
+				application_interface->GetSceneTreeControl()->HideNode(lpO->handle_of_tree_node);
+		}
+	}
+}
+
+void attach_item_head_z(NUM_LIST num, lpLISTH listh, VADR hitem){
+	LIST_ZUDINA = num;
+	attach_item_head(listh, hitem);
+  LIST_ZUDINA = OBJ_LIST;
+}
+void attach_item_tail_z(NUM_LIST num, lpLISTH listh, VADR hitem){
+	LIST_ZUDINA = num;
+	attach_item_tail(listh, hitem);
+  LIST_ZUDINA = OBJ_LIST;
+}
+void get_next_item_z(NUM_LIST num, VADR hitem, VADR * hnext){
+	LIST_ZUDINA = num;
+	get_next_item(hitem, hnext);
+  LIST_ZUDINA = OBJ_LIST;
+}
+void get_prev_item_z(NUM_LIST num, VADR hitem, VADR * hprev){
+	LIST_ZUDINA = num;
+	get_prev_item(hitem, hprev);
+  LIST_ZUDINA = OBJ_LIST;
+}
+void detach_item_z(NUM_LIST num, lpLISTH listh, VADR hitem)
+{
+	LIST_ZUDINA = num;
+	detach_item(listh, hitem);
+	if (num==OBJ_LIST)
+	{
+		lpOBJ lpO = (lpOBJ)hitem;
+		SG_POINT pMax,pMin;
+		lpO->extendedClass->GetGabarits(pMin,pMax);
+		if (fabs(pMin.x-scene_min.x)<0.0000001 ||
+			fabs(pMin.y-scene_min.y)<0.0000001 ||
+			fabs(pMin.z-scene_min.z)<0.0000001 ||
+			fabs(pMax.x-scene_max.x)<0.0000001 ||
+			fabs(pMax.y-scene_max.y)<0.0000001 ||
+			fabs(pMax.z-scene_max.z)<0.0000001)
+				get_scene_limits();
+	}
+    LIST_ZUDINA = OBJ_LIST;
+}
+
+

CSG/sgCore/Core/O_UTIL/U_RCD.cpp

@@ -0,0 +1,973 @@
+#include "../sg.h"
+
+BOOL rcd_test_expression(lpRECORDSET rcd, char *express, BOOL *res);
+static BOOL rcd_load(lpRECORDSET rcd, int irec);
+static BOOL rcd_find(lpRECORDSET rcd, char *str, int sirec, int eirec, short step);
+
+BOOL rcd_create(lpRECORDSET rcd, char* name, lpRCDFIELD fld, short numfld)
+{
+short          i;
+WORD           len, lrec;
+char           *hdrec;
+UCHAR          *hdfield;
+
+	memset(rcd, 0, sizeof(RECORDSET));
+	//  
+	if(numfld <= 0 || numfld > 255)
+		goto badfld;
+	for(i = 0; i < numfld; i++){
+		if(strlen(fld[i].name) > 10)
+			goto badfld;
+		switch(fld[i].type){
+			case 'C':
+			case 'c':
+			case 'N':
+			case 'n':
+			case 'L':
+			case 'l':
+				break;
+			default:
+				goto badfld;
+		}
+		if(fld[i].size <= fld[i].prec)
+			goto badfld;
+	}
+
+	if(!init_buf(&rcd->bd, name, BUF_NEW)){
+		rcd->err = RCDERR_OPEN;
+		return FALSE;
+	}
+
+	//    
+	//    
+	len = (WORD)(32*(numfld + 1) + 1);
+	if((hdrec = (char*)SGMalloc(len)) == NULL) {
+		rcd->err = RCDERR_NOMEM;
+		return FALSE;
+	}
+	memset(hdrec, 0, len);
+	hdfield = (UCHAR*)(hdrec + 32);
+	//   
+	lrec = 0;
+	for(i = 0; i < numfld; i++){
+		strcpy((char*)hdfield, fld[i].name);
+		hdfield[11] = (UCHAR)toupper(fld[i].type);
+		hdfield[16] = (BYTE)((hdfield[11] == 'L') ? 1: fld[i].size);
+		hdfield[17] = (BYTE)((hdfield[11] == 'N') ? fld[i].prec : 0);
+		lrec = (WORD)(lrec + fld[i].size);
+		hdfield += 32;
+	}
+	*hdrec = 0x03;
+  GetCurrentDateForDbf(hdrec + 1);
+	*((int*)(hdrec + 4)) = 0; // 
+	*((WORD*)(hdrec+ 8)) = len;
+	*((WORD*)(hdrec + 10)) = lrec + 1;
+	*(hdrec + len - 1) = 0x0D;
+	if(!story_data(&rcd->bd, len, hdrec)){
+		rcd->err = RCDERR_WRITE;
+		SGFree(hdrec);
+ //nb 		hdrec = NULL;
+		rcd_close(rcd);
+		return FALSE;
+	}
+	SGFree(hdrec);
+ //	hdrec = NULL;
+	if(!rcd_close(rcd))
+		return FALSE;
+	return rcd_open(rcd, name, NULL);
+badfld:
+	rcd->err = RCDERR_BADFIELD;
+	return FALSE;
+}
+
+BOOL rcd_open(lpRECORDSET rcd, char* name, char*filter)
+{
+char              hdr[32];
+char              *hdrec;
+long              recnum, offset, irec;
+WORD              lhdr, lrec, lcontrol;
+short             fldnum, i;
+RCDFIELD          dbfld;
+RCDRECINFO        ri;
+
+	memset(rcd, 0, sizeof(RECORDSET));
+	if(!init_buf(&rcd->bd, name, BUF_OLD)){
+		rcd->err = RCDERR_OPEN;
+		return FALSE;
+	}
+	init_vdim(&rcd->vd, sizeof(RCDRECINFO));
+	if(load_data(&rcd->bd, 32, hdr) < 32) goto badfile;
+//   
+	hdrec = hdr;
+	if((*hdrec & 0x03) != (0x03)) goto badfile;
+	hdrec += 4; //  
+	recnum = *((int*)hdrec); //   
+	if(recnum < 0 ) goto badfile;
+	hdrec += 4;
+	lhdr 	= *((WORD*)hdrec); //   
+	fldnum = (short)((lhdr - 33)/32);
+	if(fldnum <= 0 || fldnum > 255) goto badfile;
+	if((fldnum + 1)*32 + 1 != lhdr) goto badfile;
+	hdrec += 2; //   
+	lrec 	= *((WORD*)hdrec); //   
+	if(lrec == 0 || lrec > 4000) goto badfile;
+	if((ULONG)(lrec*recnum + lhdr + ((recnum) ? 1:0)) != rcd->bd.len_file) goto badfile;
+	if(hdr[15] != 0) goto codefile;
+	if((rcd->record = (char*)SGMalloc(lrec)) == NULL) goto nomem;
+	if((rcd->fld = (RCDFIELD*)SGMalloc(fldnum*sizeof(RCDFIELD))) == NULL) goto nomem;
+	//   ,   
+	lcontrol = 1;
+	for(i = 0; i < fldnum; i++){
+		if(load_data(&rcd->bd, 32, hdr) != 32) goto badfile;
+		if(hdr[10] != 0) goto badfile;
+		if(strlen(hdr) == 0) goto badfile;
+//		if(!test_to_fldname(hdr)) goto badfile;
+		strcpy(dbfld.name, hdr);
+		dbfld.type = hdr[11];
+		dbfld.size = (UCHAR)hdr[16];
+		dbfld.prec = (UCHAR)hdr[17];
+		lcontrol += dbfld.size;
+		if(lcontrol > lrec) goto badfile;
+		if(dbfld.prec >= dbfld.size) goto badfile;
+		if(dbfld.type != 'N' && dbfld.type != 'F' && dbfld.prec != 0) goto badfile;
+		rcd->fld[i] = dbfld;
+	}
+	if(load_data(&rcd->bd, 1, &hdr) != 1) goto badfile;
+	if(hdr[0] != 0x0D) goto badfile;
+	//   
+	rcd->fldnum = fldnum;
+	rcd->recnum = recnum;
+	rcd->recsize = lrec;
+	//  vdim c  
+	rcd->boffset = get_buf_offset(&rcd->bd);
+	for(irec = 0; irec < rcd->recnum; irec++){
+		offset = get_buf_offset(&rcd->bd);
+		if(load_data(&rcd->bd, rcd->recsize, rcd->record) != rcd->recsize) goto badfile;
+		if(rcd->record[0] == 0x20){ // 
+			ri.bmk = irec + 1;
+			ri.offset = offset;
+			if(!add_elem(&rcd->vd, &ri)) goto nomem;
+		}
+	}
+	if(recnum){
+		if(load_data(&rcd->bd, 1, hdr) != 1) goto badfile;
+		if(hdr[0] != 0x1A) goto badfile;
+	}
+	rcd->realnum = rcd->vd.num_elem;
+	rcd->irec = 0;
+	if(rcd->realnum)
+		if(!rcd_load(rcd, 1))
+			goto err;
+	if(filter)
+		if(!rcd_filter(rcd, filter))
+			goto err;
+	 return TRUE;
+
+badfile:
+	rcd->err = RCDERR_BADFILE;
+	rcd_close(rcd);
+	return FALSE;
+codefile:
+	rcd->err = RCDERR_CODEFILE;
+	rcd_close(rcd);
+	return FALSE;
+nomem:
+	rcd->err = RCDERR_NOMEM;
+err:
+	rcd_close(rcd);
+	return FALSE;
+}
+
+BOOL rcd_open_by_id(lpRECORDSET rcd, char* name,
+										char* fldnm, sgFloat* id, short numid)
+
+{
+char              hdr[32];
+char              *hdrec;
+long              recnum, offset, irec;
+WORD              lhdr, lrec, lcontrol;
+short             fldnum, i, fldpos, fldsize, fldid = -1;
+sgFloat            num;
+RCDFIELD          dbfld;
+RCDRECINFO        ri;
+
+	memset(rcd, 0, sizeof(RECORDSET));
+	if(!init_buf(&rcd->bd, name, BUF_OLD)){
+		rcd->err = RCDERR_OPEN;
+		return FALSE;
+	}
+	init_vdim(&rcd->vd, sizeof(RCDRECINFO));
+	if(load_data(&rcd->bd, 32, hdr) < 32) goto badfile;
+//   
+	hdrec = hdr;
+	if((*hdrec & 0x03) != (0x03)) goto badfile;
+	hdrec += 4; //  
+	recnum = *((int*)hdrec); //   
+	if(recnum < 0 ) goto badfile;
+	hdrec += 4;
+	lhdr 	= *((WORD*)hdrec); //   
+	fldnum = (short)((lhdr - 33)/32);
+	if(fldnum <= 0 || fldnum > 255) goto badfile;
+	if((fldnum + 1)*32 + 1 != lhdr) goto badfile;
+	hdrec += 2; //   
+	lrec 	= *((WORD*)hdrec); //   
+	if(lrec == 0 || lrec > 4000) goto badfile;
+	if((ULONG)(lrec*recnum + lhdr + ((recnum) ? 1:0)) != rcd->bd.len_file) goto badfile;
+	if(hdr[15] != 0) goto codefile;
+	if((rcd->record = (char*)SGMalloc(lrec)) == NULL) goto nomem;
+	if((rcd->fld = (RCDFIELD*)SGMalloc(fldnum*sizeof(RCDFIELD))) == NULL) goto nomem;
+	//   ,   
+	lcontrol = 1;
+	for(i = 0; i < fldnum; i++){
+		if(load_data(&rcd->bd, 32, hdr) != 32) goto badfile;
+		if(hdr[10] != 0) goto badfile;
+		if(strlen(hdr) == 0) goto badfile;
+//		if(!test_to_fldname(hdr)) goto badfile;
+		strcpy(dbfld.name, hdr);
+		dbfld.type = hdr[11];
+		dbfld.size = (UCHAR)hdr[16];
+		dbfld.prec = (UCHAR)hdr[17];
+		lcontrol += dbfld.size;
+		if(lcontrol > lrec) goto badfile;
+		if(dbfld.prec >= dbfld.size) goto badfile;
+		if(dbfld.type != 'N' && dbfld.type != 'F' && dbfld.prec != 0) goto badfile;
+		rcd->fld[i] = dbfld;
+		if(fldid < 0){
+			if((!strcmp(dbfld.name, fldnm)) && (dbfld.type == 'N')){
+				fldid = i;
+				fldsize = dbfld.size;
+				fldpos = (short)(lcontrol - dbfld.size);
+			}
+		}
+	}
+	if(load_data(&rcd->bd, 1, &hdr) != 1) goto badfile;
+	if(hdr[0] != 0x0D) goto badfile;
+	//   
+	rcd->fldnum = fldnum;
+	rcd->recnum = recnum;
+	rcd->recsize = lrec;
+	//  vdim c  
+	rcd->boffset = get_buf_offset(&rcd->bd);
+	for(irec = 0; irec < rcd->recnum; irec++){
+		offset = get_buf_offset(&rcd->bd);
+		if(load_data(&rcd->bd, rcd->recsize, rcd->record) != rcd->recsize) goto badfile;
+		if(rcd->record[0] != 0x20) continue; // 
+		if(fldid < 0) continue;
+		rcd->record[fldpos+fldsize] = 0;
+		if(!z_text_to_sgFloat(&rcd->record[fldpos], &num, ((short*)&i))) continue;
+		for(i = 0; i < numid; i++){
+			if(id[i] == num)
+				goto metadd;
+		}
+		continue;
+metadd:
+		ri.bmk = irec + 1;
+		ri.offset = offset;
+		if(!add_elem(&rcd->vd, &ri)) goto nomem;
+	}
+	if(recnum){
+		if(load_data(&rcd->bd, 1, hdr) != 1) goto badfile;
+		if(hdr[0] != 0x1A) goto badfile;
+	}
+	rcd->realnum = rcd->vd.num_elem;
+	rcd->irec = 0;
+	if(rcd->realnum)
+		if(!rcd_load(rcd, 1))
+			goto err;
+	return TRUE;
+
+badfile:
+	rcd->err = RCDERR_BADFILE;
+	rcd_close(rcd);
+	return FALSE;
+codefile:
+	rcd->err = RCDERR_CODEFILE;
+	rcd_close(rcd);
+	return FALSE;
+nomem:
+	rcd->err = RCDERR_NOMEM;
+err:
+	rcd_close(rcd);
+	return FALSE;
+}
+
+
+BOOL rcd_move(lpRECORDSET rcd, int rnum, RCDBOOKMARK bmk)
+{
+int       irec;
+RCDRECINFO ri;
+
+	rcd->newrec = 0;
+	if(bmk != 0){  //  
+		if(bmk > 0 && bmk <= rcd->recnum){
+			for(irec = 1; irec <= rcd->realnum; irec++){
+				if(!read_elem(&rcd->vd, irec - 1, &ri)){
+					rcd->err = RCDERR_INTERNAL;
+					return FALSE;
+				}
+				if(ri.bmk == bmk){
+					if(!seek_buf(&rcd->bd, ri.offset))goto rerr;
+					if(load_data(&rcd->bd, rcd->recsize, rcd->record) != rcd->recsize) goto rerr;
+					rcd->irec = irec;
+					rcd->bmk = ri.bmk;
+					return TRUE;
+				}
+			}
+		}
+		rcd->err = RCDERR_BOOKMARK;
+		return FALSE;
+	}
+	//  
+	if((rcd_BOF(rcd) && rnum < 0) || (rcd_EOF(rcd) && rnum > 0)) {
+		rcd->err = RCDERR_NOCURRPOS;
+		return FALSE;
+	}
+	irec = rcd->irec + rnum;
+	if(irec <= 0){
+		rcd->irec = 0;
+		rcd->bmk = 0;
+		return TRUE;
+	}
+	if(irec > rcd->realnum){
+		rcd->irec = rcd->realnum + 1;
+		rcd->bmk = 0;
+		return TRUE;
+	}
+	return rcd_load(rcd, irec);
+rerr:
+	rcd->err = RCDERR_REED;
+	return FALSE;
+}
+
+static BOOL rcd_load(lpRECORDSET rcd, int irec)
+{
+RCDRECINFO ri;
+
+	rcd->newrec = 0;
+	if(irec <= 0 || irec > rcd->realnum) {
+		rcd->err = RCDERR_NOCURRPOS;
+		return FALSE;
+	}
+	if(!read_elem(&rcd->vd, irec - 1, &ri)){
+		rcd->err = RCDERR_INTERNAL;
+		return FALSE;
+	}
+	if(!seek_buf(&rcd->bd, ri.offset))goto rerr;
+	if(load_data(&rcd->bd, rcd->recsize, rcd->record) != rcd->recsize) goto rerr;
+	rcd->irec = irec;
+	rcd->bmk = ri.bmk;
+	return TRUE;
+rerr:
+	rcd->err = RCDERR_REED;
+	return FALSE;
+}
+
+BOOL rcd_move_first(lpRECORDSET rcd)
+{
+	return rcd_load(rcd, 1);
+}
+
+BOOL rcd_move_last(lpRECORDSET rcd)
+{
+	return rcd_load(rcd, rcd->realnum);
+}
+BOOL rcd_move_next(lpRECORDSET rcd)
+{
+	return rcd_move(rcd, 1, 0);
+}
+BOOL rcd_move_previous(lpRECORDSET rcd)
+{
+	return rcd_move(rcd, -1, 0);
+}
+
+BOOL rcd_BOF(lpRECORDSET rcd){
+	if(rcd->irec <= 0 || rcd->realnum == 0) return TRUE;
+	return FALSE;
+}
+
+BOOL rcd_EOF(lpRECORDSET rcd){
+	if(rcd->irec > rcd->realnum || rcd->realnum == 0) return TRUE;
+	return FALSE;
+}
+
+RCDBOOKMARK rcd_bookmark(lpRECORDSET rcd){
+	if(rcd->irec <= 0 || rcd->irec > rcd->realnum || rcd->realnum == 0){
+		rcd->err = RCDERR_NOCURRPOS;
+		return 0;
+	}
+
+	return rcd->bmk;
+}
+
+
+BOOL rcd_getvalue_bynum(lpRECORDSET rcd, short fieldnum, void * value)
+{
+char  buf[256];
+short ifld, i, errcode;
+
+	if(!rcd_bookmark(rcd) && !rcd->newrec) return FALSE;
+	if(fieldnum < 0 || fieldnum >= rcd->fldnum){
+		rcd->err = RCDERR_BADFIELDNUM;
+		return FALSE;
+	}
+	ifld = 1;
+	for(i = 0; i < fieldnum; i++)
+		ifld += rcd->fld[i].size;
+	memcpy(buf, &rcd->record[ifld], rcd->fld[fieldnum].size);
+	buf[rcd->fld[fieldnum].size] = 0;
+	switch(rcd->fld[fieldnum].type){
+		case 'C':
+		case 'c':
+			z_OemToAnsi(buf, buf, rcd->fld[fieldnum].size);
+			for(i = (short)(rcd->fld[fieldnum].size - 1); i >= 0; i--){
+				if(buf[i] == 0x20) buf[i] = 0;
+				else break;
+			}
+			strcpy((char*)value, buf);
+			break;
+		case 'N':
+		case 'n':
+			if(!z_text_to_sgFloat(buf, (sgFloat*)value, ((short*)&errcode))){
+				if(errcode == 0) rcd->err = RCDERR_UNKFIELDVALUE;
+				else             rcd->err = RCDERR_BADVALUE;
+				return FALSE;
+			}
+			break;
+		case 'L':
+		case 'l':
+			if(buf[0] == 'T' || buf[0] == 't' || buf[0] == 'Y' || buf[0] == 'y')
+				*((sgFloat*)value) = 1;
+			else
+				*((sgFloat*)value) = 0;
+			break;
+		default:
+			rcd->err = RCDERR_UNKFIELDTYPE;
+			return FALSE;
+	}
+	return TRUE;
+}
+
+void * rcd_alloc_and_getvalue_bynum(lpRECORDSET rcd, short fieldnum)
+{
+void * value;
+short     size;
+
+	if(!rcd_bookmark(rcd) && !rcd->newrec) return NULL;
+	if(fieldnum < 0 || fieldnum >= rcd->fldnum){
+		rcd->err = RCDERR_BADFIELDNUM;
+		return NULL;
+	}
+	switch(rcd->fld[fieldnum].type){
+		case 'C':
+		case 'c':
+			size = (short)(rcd->fld[fieldnum].size + 1);
+			break;
+		case 'N':
+		case 'n':
+		case 'L':
+		case 'l':
+			size = sizeof(sgFloat);
+			break;
+		default:
+			rcd->err = RCDERR_UNKFIELDTYPE;
+			return NULL;
+	}
+	value = SGMalloc(size);
+	if(value == NULL){
+		 rcd->err = RCDERR_NOMEM;
+		 return NULL;
+	}
+	if(!rcd_getvalue_bynum(rcd, fieldnum, value)){
+		SGFree(value);
+		return NULL;
+	}
+	return value;
+}
+
+BOOL rcd_setvalue_bynum(lpRECORDSET rcd, short fieldnum, void * value)
+{
+char   buf[256];
+short  ifld, i, len;
+sgFloat num;
+
+
+
+	if(!rcd_bookmark(rcd) && !rcd->newrec) return FALSE;
+	if(fieldnum < 0 || fieldnum >= rcd->fldnum){
+		rcd->err = RCDERR_BADFIELDNUM;
+		return FALSE;
+	}
+	ifld = 1;
+	for(i = 0; i < fieldnum; i++)
+		ifld += rcd->fld[i].size;
+
+	memset(buf, 0x20, rcd->fld[fieldnum].size);
+
+	buf[rcd->fld[fieldnum].size] = 0;
+	if(value){
+		switch(rcd->fld[fieldnum].type){
+			case 'C':
+			case 'c':
+				len = (short)strlen((char*)value);
+				if(len > rcd->fld[fieldnum].size) len = rcd->fld[fieldnum].size;
+				strncpy(buf, (char*)value, len);
+				z_AnsiToOem(buf, buf, len);
+				break;
+			case 'N':
+			case 'n':
+//nb				num = *((sgFloat*)value);
+				sgFloat_output1(*((sgFloat*)value), rcd->fld[fieldnum].size,
+																					rcd->fld[fieldnum].prec,
+											 FALSE, FALSE, FALSE, buf);
+				break;
+			case 'L':
+			case 'l':
+				num = *((sgFloat*)value);
+				buf[0] = (BYTE)((num != 0.) ? 'T':'F');
+				break;
+			default:
+				rcd->err = RCDERR_UNKFIELDTYPE;
+				return FALSE;
+		}
+	}
+	memcpy(&rcd->record[ifld], buf, rcd->fld[fieldnum].size);
+	return TRUE;
+}
+
+void rcd_addnew(lpRECORDSET rcd)
+{
+	rcd->newrec = 1;
+	memset(rcd->record, ' ', rcd->recsize);
+}
+
+BOOL rcd_update(lpRECORDSET rcd)
+{
+int offset, irec;
+char c;
+RCDRECINFO ri;
+
+	if(rcd->newrec){
+		offset = rcd->boffset + rcd->recnum*rcd->recsize;
+		if(!seek_buf(&rcd->bd, offset))
+			goto rerr;
+		if(!story_data(&rcd->bd, rcd->recsize, rcd->record))
+			goto rerr;
+		c = 0x1A;
+		if(!story_data(&rcd->bd, 1, &c))
+			goto rerr;
+		irec = rcd->recnum + 1;
+		if(!seek_buf(&rcd->bd, 4))
+			goto rerr;
+		if(!story_data(&rcd->bd, 4, &irec))
+			goto rerr;
+		ri.bmk = rcd->realnum+1;
+		ri.offset = offset;
+		if(!add_elem(&rcd->vd, &ri))
+			goto nomem;
+		rcd->recnum++;
+		rcd->realnum++;
+		rcd->newrec = 0;
+		if(rcd_bookmark(rcd))
+			return rcd_load(rcd, rcd->irec);
+		return TRUE;
+	}
+	else {
+		if(!rcd_bookmark(rcd))
+			return FALSE;
+		if(!read_elem(&rcd->vd, rcd->irec - 1, &ri)){
+			rcd->err = RCDERR_INTERNAL;
+			return FALSE;
+		}
+
+		if(!seek_buf(&rcd->bd, ri.offset))goto rerr;
+		if(!story_data(&rcd->bd, rcd->recsize, rcd->record))
+			goto rerr;
+		return TRUE;
+	}
+rerr:
+	rcd->err = RCDERR_WRITE;
+	return FALSE;
+nomem:
+	rcd->err = RCDERR_NOMEM;
+	return FALSE;
+}
+
+
+
+BOOL rcd_delete(lpRECORDSET rcd)
+{
+int i;
+char c = '*';
+RCDRECINFO ri;
+
+	if(!rcd_bookmark(rcd))
+		return FALSE;
+	if(!read_elem(&rcd->vd, rcd->irec - 1, &ri)){
+		rcd->err = RCDERR_INTERNAL;
+		return FALSE;
+	}
+	if(!seek_buf(&rcd->bd, ri.offset))
+		goto rerr;
+	if(!story_data(&rcd->bd, 1, &c))
+		goto rerr;
+	for(i = rcd->irec; i < rcd->vd.num_elem; i++){
+		if(!read_elem(&rcd->vd, i, &ri)){
+			rcd->err = RCDERR_INTERNAL;
+			return FALSE;
+		}
+		if(!write_elem(&rcd->vd, i - 1, &ri)){
+			rcd->err = RCDERR_INTERNAL;
+			return FALSE;
+		}
+	}
+	delete_elem_list(&rcd->vd, rcd->realnum - 1);
+	rcd->realnum--;
+
+	if(!rcd->realnum){
+		rcd->irec = 0;
+		rcd->bmk = 0;
+		return TRUE;
+	}
+	if(rcd->irec > rcd->realnum){
+		rcd->irec = rcd->realnum + 1;
+		rcd->bmk = 0;
+		return TRUE;
+	}
+	return rcd_load(rcd, rcd->irec);
+rerr:
+	rcd->err = RCDERR_WRITE;
+	return FALSE;
+//nb nomem:
+//	rcd->err = RCDERR_NOMEM;
+//	return FALSE;
+}
+
+BOOL rcd_getfieldnum(lpRECORDSET rcd, char *fieldname, short* fieldnum)
+{
+short i;
+
+	for(i = 0; i < rcd->fldnum; i++){
+		if(!strcmp(rcd->fld[i].name, fieldname)){
+			*fieldnum = i;
+			return TRUE;
+		}
+	}
+	rcd->err = RCDERR_BADFIELDNAME;
+	return FALSE;
+}
+
+
+BOOL rcd_getvalue(lpRECORDSET rcd, char *fieldname, void * value)
+{
+short fieldnum;
+	if(!rcd_getfieldnum(rcd, fieldname, &fieldnum)) return FALSE;
+	return rcd_getvalue_bynum(rcd, fieldnum, value);
+}
+
+BOOL rcd_setvalue(lpRECORDSET rcd, char *fieldname, void * value)
+{
+short fieldnum;
+	if(!rcd_getfieldnum(rcd, fieldname, &fieldnum)) return FALSE;
+	return rcd_setvalue_bynum(rcd, fieldnum, value);
+}
+
+
+void * rcd_alloc_and_getvalue(lpRECORDSET rcd, char *fieldname)
+{
+short fieldnum;
+	if(!rcd_getfieldnum(rcd, fieldname, &fieldnum)) return NULL;
+	return rcd_alloc_and_getvalue_bynum(rcd, fieldnum);
+}
+
+short rcd_fields_count(lpRECORDSET rcd)
+{
+	return rcd->fldnum;
+}
+
+int rcd_records_count(lpRECORDSET rcd)
+{
+	return rcd->realnum;
+}
+
+BOOL rcd_field_info(lpRECORDSET rcd, short fieldnum, lpRCDFIELD fieldinfo)
+{
+	if(fieldnum < 0 || fieldnum >= rcd->fldnum){
+		rcd->err = RCDERR_BADFIELDNUM;
+		return FALSE;
+	}
+	*fieldinfo = rcd->fld[fieldnum];
+	return TRUE;
+}
+
+BOOL rcd_close(lpRECORDSET rcd)
+//   
+{
+	if(rcd->fld) SGFree(rcd->fld);
+	rcd->fld = NULL;
+	if(rcd->record) SGFree(rcd->record);
+	rcd->record = NULL;
+	if(rcd->filter) SGFree(rcd->filter);
+	rcd->filter = NULL;
+	free_vdim(&rcd->vd);
+	if(!close_buf(&rcd->bd)){
+		rcd->err = RCDERR_CLOSE;
+		return FALSE;
+	}
+	return TRUE;
+}
+
+
+
+void rcd_put_message(lpRECORDSET rcd)
+{
+	put_message(MSG_RCDERR_NOERR + rcd->err, NULL, 0);
+}
+
+static BOOL rcd_find(lpRECORDSET rcd, char *str, int sirec, int eirec, short step)
+{
+BOOL res;
+int irec;
+
+	rcd->newrec = 0;
+	rcd->nomatch = 0;
+	irec = rcd->irec;
+	if(!rcd->realnum)
+		goto nomatch;
+	if(sirec < eirec && step < 0)
+		goto nomatch;
+	if(sirec > eirec && step > 0)
+		goto nomatch;
+
+	do {
+		if(sirec != rcd->irec)
+			if(!rcd_load(rcd, sirec))
+				return FALSE;
+		if(!rcd_test_expression(rcd, str, &res))
+			return FALSE;
+		if(res)
+			return TRUE;
+		sirec = sirec + step;
+	}	while(sirec != eirec + step);
+nomatch:
+	rcd->nomatch = 1;
+	if(irec <= 0){
+		rcd->irec = 0;
+		rcd->bmk = 0;
+		return TRUE;
+	}
+	if(irec > rcd->realnum){
+		rcd->irec = rcd->realnum + 1;
+		rcd->bmk = 0;
+		return TRUE;
+	}
+	return rcd_load(rcd, irec);
+}
+
+BOOL rcd_find_first(lpRECORDSET rcd, char *str)
+{
+	return rcd_find(rcd, str, 1, rcd->realnum, 1);
+}
+
+BOOL rcd_find_next(lpRECORDSET rcd, char *str)
+{
+	return rcd_find(rcd, str, rcd->irec + 1, rcd->realnum, 1);
+}
+
+BOOL rcd_find_previous(lpRECORDSET rcd, char *str)
+{
+	return rcd_find(rcd, str, rcd->irec - 1, 1, -1);
+}
+
+BOOL rcd_find_last(lpRECORDSET rcd, char *str)
+{
+	return rcd_find(rcd, str, rcd->realnum, 1, -1);
+}
+
+BOOL rcd_nomatch(lpRECORDSET rcd)
+{
+	return (rcd->nomatch) ? TRUE:FALSE;
+}
+
+BOOL rcd_filter(lpRECORDSET rcd, char *str)
+{
+short      l;
+BOOL       res, oldfilter = FALSE;
+int       irec, irecf, offset;
+char       hdr;
+RCDRECINFO ri;
+	rcd->newrec = 0;
+
+	if(rcd->filter){
+		oldfilter = TRUE;
+		SGFree(rcd->filter);
+		rcd->filter = NULL;
+	}
+	if(str != NULL){
+		l = (short)strlen(str);
+		if(l != 0){
+			if((rcd->filter = (char*)SGMalloc(l + 1)) == NULL) goto merr;
+			strcpy(rcd->filter, str);
+		}
+	}
+	if(oldfilter){
+		free_vdim(&rcd->vd);
+		init_vdim(&rcd->vd, sizeof(RCDRECINFO));
+		if(!seek_buf(&rcd->bd, rcd->boffset))goto rerr;
+		for(irec = 0; irec < rcd->recnum; irec++){
+			offset = get_buf_offset(&rcd->bd);
+			if(load_data(&rcd->bd, rcd->recsize, rcd->record) != rcd->recsize) goto badfile;
+			if(rcd->record[0] == 0x20){ // 
+				ri.bmk = irec + 1;
+				ri.offset = offset;
+				if(!add_elem(&rcd->vd, &ri)) goto merr;
+			}
+		}
+		if(rcd->recnum){
+			if(load_data(&rcd->bd, 1, &hdr) != 1) goto badfile;
+			if(hdr != 0x1A) goto badfile;
+		}
+		rcd->realnum = rcd->vd.num_elem;
+		rcd->irec = 0;
+		rcd->bmk = 0;
+	}
+	if(!rcd->realnum)
+		return TRUE;
+	if(!rcd->filter)
+		return rcd_move_first(rcd);
+	//     
+	irecf = 0;
+	for(irec = 0; irec < rcd->realnum; irec++){
+		if(!rcd_load(rcd, irec + 1))
+			goto err;
+		if(!rcd_test_expression(rcd, rcd->filter, &res))
+			goto err;
+		if(res){
+			if(irecf != irec){
+				if(!read_elem(&rcd->vd, irec, &ri))
+					goto ierr;
+				if(!write_elem(&rcd->vd, irecf, &ri))
+					goto ierr;
+			}
+			irecf++;
+		}
+	}
+	rcd->irec = 0;
+	if(irecf < rcd->realnum){
+		delete_elem_list(&rcd->vd, irecf);
+		rcd->realnum = rcd->vd.num_elem;
+		rcd->irec = 0;
+		rcd->bmk = 0;
+		if(!rcd->realnum) return TRUE;
+	}
+	return rcd_move_first(rcd);
+badfile:
+	rcd->err = RCDERR_BADFILE;
+	return FALSE;
+merr:
+	rcd->err = RCDERR_NOMEM;
+	return FALSE;
+ierr:
+	rcd->err = RCDERR_INTERNAL;
+	return FALSE;
+rerr:
+	rcd->err = RCDERR_REED;
+err:
+	return FALSE;
+}
+
+BOOL rcd_test_expression(lpRECORDSET rcd, char *express, BOOL *res)
+  
+{
+/*int            ibegvar, ibegarr, ibeglvar, ibeglarr, iglb;
+ULONG          len;
+UCHAR          type, s;
+void        *value;
+lpBOOL_VALUE   bv;
+BOOL           ret = FALSE;
+short            i;
+
+	*res = FALSE;
+
+//   
+	ibegvar = ucd->vd.num_elem;
+	ibegarr = ucd->vda.num_elem;
+	ibeglvar = ucd->vdl.num_elem;
+	ibeglarr = ucd->vdla.num_elem;
+	iglb = ucd->vdglb.num_elem;
+
+//     
+	for(i = 0; i < rcd->fldnum; i++){
+		value = rcd_alloc_and_getvalue_bynum(rcd, (short)i);
+		if(!value){
+			if(rcd->err != RCDERR_UNKFIELDVALUE)
+				goto err;
+			continue;
+		}
+		switch(rcd->fld[i].type){
+			case 'C':
+			case 'c':
+				type = UC_STRING;
+				break;
+			case 'N':
+			case 'n':
+			case 'L':
+			case 'l':
+				type = UC_NUM;
+				break;
+			default:
+				continue;
+		}
+		if(!uc_assign_variable(rcd->fld[i].name, type, value)){
+			rcd->err = RCDERR_CALCULATION;
+			goto err;
+		}
+		SGFree(value);
+ //nb 		value = NULL;
+	}
+//nb met:
+	value = uc_alloc_and_get_express_value_s(express, &type, &len, &s);
+	if(!value) {
+		if(ucd->err == UC_NODEFINE) goto metend;
+		rcd->err = RCDERR_SYNTAX;
+		goto err;
+	}
+	if(s != UC_NORMAL){
+		put_message(ERR_LOGICAL_EXPRESSION, NULL, 0);
+		rcd->err = RCDERR_SYNTAX;
+		goto err;
+	}
+	switch(type){
+		case UC_NUM:
+			if(*((sgFloat*)value) != 0.) *res = TRUE;
+			break;
+		case UC_BOOL:
+			bv = (lpBOOL_VALUE)value;
+			if(bv->b) *res = TRUE;
+			break;
+		default:
+			rcd->err = RCDERR_SYNTAX;
+			goto err;
+	}
+metend:
+	ret = TRUE;
+err:
+	if(value)	SGFree(value);
+	uc_free_var_list(ibegvar, ibegarr);
+	uc_free_loc_var_list(ibeglvar, ibeglarr, iglb);
+	return ret;*/return FALSE;
+}
+
+
+void GetCurrentDateForDbf(char* sd)
+{
+struct tm 	*newtime;
+time_t 			long_time;
+
+	tzset();
+	long_time = GetCurrentDateTime();
+	newtime = localtime( &long_time );
+  sd[0] = (char)newtime->tm_year;
+  sd[1] = (char)newtime->tm_mon + 1;
+  sd[2] = (char)newtime->tm_mday;
+  return;
+}

CSG/sgCore/Core/O_UTIL/U_VIRTBD.cpp

@@ -0,0 +1,211 @@
+#include "../sg.h"
+
+typedef struct {
+  VI_LOCATION loc;            
+  ULONG       len;         
+}STR_IM;
+typedef STR_IM * lpSTR_IM;
+
+void init_vbd(lpVIRT_BD vbd)
+{
+  init_vld(&vbd->vld);
+  init_vdim(&vbd->vdim, sizeof(STR_IM));
+  vbd->ind_free   = 0;
+  vbd->free_space = 0;
+  vbd->max_len    = 1;
+}
+
+BOOL free_vbd(lpVIRT_BD vbd)
+{
+	free_vld_data(&vbd->vld);
+	free_vdim(&vbd->vdim);
+	vbd->ind_free   = 0;
+	vbd->free_space = 0;
+	vbd->max_len    = 0;
+  return TRUE;
+}
+
+IDENT_V vbd_add_str(lpVIRT_BD vbd, char * str)
+{
+  return vbd_add_data(vbd, strlen(str) + 1, str);
+}
+
+BOOL  vbd_get_str(lpVIRT_BD vbd, IDENT_V ident, char * str)
+{
+STR_IM im;
+
+	ident--;
+  if(!read_elem(&vbd->vdim, ident, &im)) return FALSE;
+  if(!load_vld_data(&im.loc, im.len, str)) return FALSE;
+	return TRUE;
+}
+BOOL vbd_write_data(lpVIRT_BD vbd, IDENT_V ident, void * data)
+{
+STR_IM im;
+
+	ident--;
+  if(!read_elem(&vbd->vdim, ident, &im)) return FALSE;
+	rezet_vld_data(&im.loc, im.len, data);
+	return TRUE;
+}
+IDENT_V vbd_add_data(lpVIRT_BD vbd, ULONG len, void * data)
+{
+long      i;
+lpSTR_IM  lpim;
+STR_IM    im;
+
+  if(len == 0xFFFFFFFF || len == 0) return 0;
+	if(len > vbd->max_len) vbd->max_len = len;
+	if(vbd->vld.mem)
+	 if(((sgFloat)vbd->free_space)/(vbd->vld.mem) > .3 && vbd->vld.listh.num > 2)
+		 if(!vbd_sborka_musora(vbd)) return 0;
+  memset(&im, 0, sizeof(im));
+  im.loc = vbd->vld.viloc;
+	im.len = len;
+  if(!add_vld_data(&vbd->vld, len, data)) return 0;
+  if(!im.loc.hpage) {
+    im.loc.hpage  = vbd->vld.listh.hhead;
+		im.loc.offset	= sizeof(RAW);
+	}
+  i = vbd->ind_free;
+  if(i >= vbd->vdim.num_elem) {
+    if(!add_elem(&vbd->vdim, &im)) return 0;
+    vbd->ind_free++;
+	} else {
+		if(0 ==(lpim = (STR_IM*)get_elem(&vbd->vdim, vbd->ind_free))) return 0;
+    vbd->ind_free  = *(long*)lpim;
+    *lpim          = im;
+	}
+  return i + 1;
+}
+
+BOOL  vbd_del_data(lpVIRT_BD vbd, IDENT_V ident)
+{
+lpSTR_IM lpim;
+
+  ident--;
+  if(0 ==(lpim = (STR_IM*)get_elem(&vbd->vdim, ident))) return FALSE;
+  if(lpim->len == 0xFFFFFFFF) return FALSE;
+  vbd->free_space += lpim->len;
+  *(long*)lpim    = vbd->ind_free;
+  lpim->len     = 0xFFFFFFFF;          // ,   
+  vbd->ind_free = ident;
+	return TRUE;
+}
+
+BOOL  vbd_load_data(lpVIRT_BD vbd, IDENT_V ident, void* data)
+{
+STR_IM im;
+	ident--;
+  if(!read_elem(&vbd->vdim, ident, &im)) return FALSE;
+  if(!load_vld_data(&im.loc, im.len, data)) return FALSE;
+	return TRUE;
+}
+
+BOOL  vbd_get_len(lpVIRT_BD vbd, IDENT_V ident, ULONG *len)
+{
+STR_IM im;
+	ident--;
+  if(!read_elem(&vbd->vdim, ident, &im)) return FALSE;
+  *len = im.len;
+	return TRUE;
+}
+
+BOOL vbd_sborka_musora(lpVIRT_BD vbd)
+{
+long          i;
+VLD           vld;
+char          *buf;
+lpSTR_IM      im;
+VI_LOCATION   loc;
+
+  if(0 ==(buf = (char*)SGMalloc(vbd->max_len))) goto err;
+  init_vld(&vld);
+
+//   VLD
+  begin_rw(&vbd->vdim, 0);
+  for(i = 0; i < vbd->vdim.num_elem; i++) {
+    im = (STR_IM*)get_next_elem(&vbd->vdim);
+    if(im->len == 0xFFFFFFFF) continue;
+    if(!load_vld_data(&im->loc, im->len, buf)) goto err;
+    if(!add_vld_data(&vld, im->len, buf))      goto err;
+  }
+  SGFree(buf);
+  end_rw(&vbd->vdim);
+  free_vld_data(&vbd->vld);  //    
+
+//   
+  loc.hpage		= vld.listh.hhead;
+  loc.offset	= sizeof(RAW);
+  begin_rw(&vbd->vdim, 0);
+  begin_read_vld(&loc);
+  for(i = 0; i< vbd->vdim.num_elem; i++) {
+    im = (STR_IM*)get_next_elem(&vbd->vdim);
+    if(im->len == 0xFFFFFFFF) continue;
+		get_read_loc(&im->loc);
+    read_vld_data(im->len, NULL);
+  }
+  end_read_vld();
+  end_rw(&vbd->vdim);
+
+  vbd->free_space = 0;
+  vbd->vld = vld;
+  return TRUE;
+err:
+  if(buf)
+    SGFree(buf);
+  vbd->free_space = 0;
+  free_vld_data(&vld);
+  return FALSE;
+}
+
+
+BOOL vbd_copy(lpVIRT_BD OldVbd, lpVIRT_BD NewVbd)
+{
+
+long          i;
+char          *buf;
+lpSTR_IM      im;
+VI_LOCATION   loc;
+
+  init_vbd(NewVbd);
+  if(NULL == (buf = (char*)SGMalloc(OldVbd->max_len))) goto err;
+
+//   VLD
+  begin_rw(&OldVbd->vdim, 0);
+  for(i = 0; i < OldVbd->vdim.num_elem; i++) {
+    im = (STR_IM*)get_next_elem(&OldVbd->vdim);
+    if(!add_elem(&NewVbd->vdim, im)) goto err;
+    if(im->len == 0xFFFFFFFF) continue;
+    if(!load_vld_data(&im->loc, im->len, buf)) goto err;
+    if(!add_vld_data(&NewVbd->vld, im->len, buf))      goto err;
+  }
+  SGFree(buf);
+  end_rw(&OldVbd->vdim);
+
+//   
+  loc.hpage		= NewVbd->vld.listh.hhead;
+  loc.offset	= sizeof(RAW);
+  begin_rw(&NewVbd->vdim, 0);
+  begin_read_vld(&loc);
+  for(i = 0; i < NewVbd->vdim.num_elem; i++) {
+    im = (STR_IM*)get_next_elem(&NewVbd->vdim);
+    if(im->len == 0xFFFFFFFF) continue;
+		get_read_loc(&im->loc);
+    read_vld_data(im->len, NULL);
+  }
+  end_read_vld();
+  end_rw(&NewVbd->vdim);
+
+  NewVbd->ind_free = OldVbd->ind_free;
+  NewVbd->free_space = 0;
+  NewVbd->max_len    = OldVbd->max_len;
+  return TRUE;
+err:
+  if(buf)
+    SGFree(buf);
+  NewVbd->free_space = 0;
+  free_vld_data(&NewVbd->vld);
+  return FALSE;
+}
+

CSG/sgCore/Core/O_UTIL/U_VLD.cpp

@@ -0,0 +1,243 @@
+#include "../sg.h"
+
+static 	VI_LOCATION 	loc1;
+static 	lpRAW	 		 		lprawg = NULL;
+
+BOOL  add_vpage(lpVLD lpvld);
+
+void init_vld(lpVLD vld)
+{
+  memset(vld, 0, sizeof(VLD));
+}
+void  rezet_vld_data(lpVI_LOCATION lploc, ULONG len, void* p)
+{
+	WORD      len_tmp;
+	lpRAW     lpraw;
+	char*     ptmp;
+	VADR      hpage, hnext;
+	WORD      offset;
+
+	offset = lploc->offset;
+	hpage  = lploc->hpage;
+	lpraw = (lpRAW)hpage;
+	ptmp = (char*)lpraw + offset;
+	while (1) {
+		len_tmp = SIZE_VPAGE - offset;
+		if ( len_tmp > len ) len_tmp = (WORD)len;
+		memcpy( ptmp,p,len_tmp);
+		len -= len_tmp;
+		hnext = lpraw->list.hnext;
+		if ( !len ) break;
+		hpage = hnext;
+		lpraw = (lpRAW)hpage;
+		offset = sizeof(RAW);
+		ptmp = (char*)lpraw + offset;
+		reinterpret_cast<char * &>(p) += len_tmp;
+	}
+}
+void  rezet_vld_data_f(ULONG len, void* p )
+{
+	WORD      len_tmp;
+	lpRAW     lpraw;
+	char*     ptmp;
+	VADR      hnew_page;
+
+	lpraw = lprawg;
+	while (1) {
+		ptmp = (char*)lpraw + loc1.offset;
+		len_tmp = SIZE_VPAGE - loc1.offset;
+		if ( len_tmp > len ) len_tmp = (WORD)len;
+		if ( p )
+      memcpy( ptmp,p,len_tmp);
+		len -= len_tmp;
+		loc1.offset += len_tmp;
+		if ( !len ) break;
+		hnew_page = lpraw->list.hnext;
+    lpraw = (lpRAW)hnew_page;
+		lprawg = lpraw;
+		loc1.hpage  = hnew_page;
+		loc1.offset = sizeof(RAW);
+    reinterpret_cast<char * &>(p) += len_tmp;
+	}
+}
+BOOL  add_vld_data(lpVLD lpvld, ULONG len, void* p )
+{
+	ULONG       len_tmp;
+	lpRAW       lpraw;
+	char*       ptmp;
+	VADR        hnext;
+  VI_LOCATION vsave;
+
+  if ( lpvld->lprawg ) lpraw = lpvld->lprawg;
+	else {
+    if ( !lpvld->viloc.hpage ) {
+      if ( !add_vpage(lpvld) ) return FALSE;
+      lpvld->viloc.hpage = lpvld->listh.htail;
+      lpvld->viloc.offset = sizeof(RAW);
+	    lpvld->mem = 0;
+		}
+    lpraw = (lpRAW)lpvld->viloc.hpage;
+	}
+  ptmp = (char*)lpraw + lpvld->viloc.offset;
+  vsave = lpvld->viloc;      //   
+	while (1) {
+    len_tmp = SIZE_VPAGE - lpvld->viloc.offset;
+		if ( len_tmp > len ) len_tmp = len;
+		memcpy( ptmp,p,len_tmp);
+		len -= len_tmp;
+		lpraw->free_mem -= (WORD)len_tmp;
+    lpvld->viloc.offset += (WORD)len_tmp;
+    lpvld->mem += len_tmp;
+
+		if ( !len ) {
+      if ( lpvld->lprawg ) break;  //    
+			break;
+		}
+		hnext = lpraw->list.hnext;
+		if ( !hnext ) {
+      if ( !add_vpage(lpvld) ) goto err;
+      hnext = lpvld->listh.htail;
+		}
+		lpraw = (lpRAW)hnext;
+    lpvld->viloc.hpage  = hnext;
+    lpvld->viloc.offset = sizeof(RAW);
+    if ( lpvld->lprawg ) lpvld->lprawg = lpraw;
+		lpraw->free_mem     = SIZE_VPAGE - sizeof(RAW);
+		ptmp = (char*)lpraw + sizeof(RAW);
+		reinterpret_cast<char * &>(p) += len_tmp;
+	}
+	return TRUE;
+err:
+  ptmp = (char*)vsave.hpage;
+  ptmp += vsave.offset;
+  *ptmp = 0;
+  return FALSE;
+}
+
+void lock_vld_data(lpVLD vld)
+{
+  vld->lprawg =  (lpRAW)vld->viloc.hpage;
+}
+
+void unlock_vld_data(lpVLD vld)
+{
+	if ( vld->lprawg ) {
+  	vld->lprawg = NULL;
+	}
+}
+
+void begin_read_vld(lpVI_LOCATION lploc)
+{
+	lprawg = (lpRAW)lploc->hpage;
+  loc1 = *lploc;
+}
+
+void end_read_vld(void)
+{
+	lprawg = NULL;
+	memset(&loc1,0,sizeof(loc1));
+}
+void begin_rezet_vld(lpVI_LOCATION lploc)
+{
+  lprawg = (lpRAW)lploc->hpage;
+	loc1 = *lploc;
+}
+void end_rezet_vld(void)
+{
+	lprawg = NULL;
+	memset(&loc1,0,sizeof(loc1));
+}
+void get_read_loc(lpVI_LOCATION lploc)
+{
+	*lploc = loc1;
+}
+void set_read_loc(lpVI_LOCATION lploc)
+{
+  loc1 = *lploc ;
+}
+
+void  read_vld_data(ULONG len, void* p )
+{
+	WORD    len_tmp;
+	lpRAW   lpraw;
+  char    *ptmp,  *p1;
+	VADR    hnew_page;
+
+  if ( !lprawg ) goto err;
+  p1 = (char*)p;
+	lpraw = lprawg;
+	while (1) {
+		ptmp = (char*)lpraw + loc1.offset;
+		len_tmp = SIZE_VPAGE - loc1.offset;
+		if ( len_tmp > len ) len_tmp = (WORD)len;
+		if ( p )
+			memcpy( p,ptmp,len_tmp);
+		len -= len_tmp;
+		loc1.offset += len_tmp;
+
+		if ( !len ) break;
+
+		hnew_page = lpraw->list.hnext;
+    lprawg = NULL;
+    if ( !hnew_page ) goto err;
+		lpraw = (lpRAW)hnew_page;
+		lprawg = lpraw;
+		loc1.hpage  = hnew_page;
+		loc1.offset = sizeof(RAW);
+		if ( p )
+			reinterpret_cast<char * &>(p) += len_tmp;
+	}
+  return;
+err:
+	if ( p1 )	memset(p1,0,len);
+}
+
+BOOL  load_vld_data(lpVI_LOCATION loc1, ULONG len, void* p )
+{
+	WORD    	  len_tmp;
+	lpRAW     	lpraw;
+  char* 	    ptmp;
+	VI_LOCATION loc;
+	VADR				hnew_page;
+
+	loc = *loc1;
+	while (1) {
+		lpraw = (lpRAW)loc.hpage;
+		ptmp = (char*)lpraw + loc.offset;
+		len_tmp = SIZE_VPAGE - loc.offset;
+		if ( len_tmp > len ) len_tmp = (WORD)len;
+		if ( p )
+			memcpy( p,ptmp,len_tmp);
+		len -= len_tmp;
+
+		hnew_page = lpraw->list.hnext;
+		if ( !len ) break;
+
+		if ( !hnew_page ) return FALSE;
+		loc.hpage  = hnew_page;
+		loc.offset = sizeof(RAW);
+		if ( p )
+			reinterpret_cast<char * &>(p) += len_tmp;
+	}
+	return TRUE;
+}
+
+void free_vld_data(lpVLD vld)
+{
+	 free_item_list(&vld->listh);
+  init_vld(vld);
+}
+
+BOOL add_vpage(lpVLD lpvld)
+{
+	lpRAW lpraw;
+	VADR  hpage;
+
+	if ( (hpage = SGMalloc(SIZE_VPAGE)) == NULL ) return FALSE;
+	lpraw = (lpRAW)hpage;
+  memset(lpraw,0,SIZE_VPAGE);
+	lpraw->free_mem = SIZE_VPAGE - sizeof(RAW);
+  lpraw->list.hprev = lpvld->listh.htail;
+  attach_item_tail(&lpvld->listh,hpage);
+	return TRUE;
+}

CSG/sgCore/Core/O_UTIL/U_VTRACE.cpp

@@ -0,0 +1,342 @@
+#include "../sg.h"
+
+unsigned long TotalMallocCount   = 0L;
+unsigned long BadMallocCount     = 0L;
+unsigned long BadReAllocCount    = 0L;
+unsigned long TotalFreeCount     = 0L;
+unsigned long BadFreeCount       = 0L;
+unsigned long TotalMallocMemSize = 0L;
+
+#define  MAXNUMMALLOC 100000
+unsigned long *pPtrs          = NULL;
+unsigned long *pMallocNumber  = NULL;
+extern   long ControlMalloc;
+long     FirstEmptyIdx = 0;
+long     AMallocLen    = 0;
+
+
+static  long   SG_MSize(void* memBlock)
+{
+#if (SG_CURRENT_PLATFORM==SG_PLATFORM_MAC)
+    return malloc_size(memBlock);
+#endif
+#if (SG_CURRENT_PLATFORM==SG_PLATFORM_WINDOWS)
+	return  _msize(memBlock);  //  MinGW
+#endif
+}
+
+//  malloc          
+//  0  
+void *SGMalloc(size_t size)
+{
+void*         v;
+long          Idx;
+unsigned long ss;
+
+	if(size <= 0){
+    StopInNullSizeMalloc();
+    FatalInternalError(2);
+    return NULL;
+  }
+	else{
+    TotalMallocCount++;
+	  v = malloc(size);
+  }
+  if(v){
+//    ss = ((*(((unsigned long*)v) - 1))>>2)<<2;
+    ss = SG_MSize(v);
+    TotalMallocMemSize += ss;
+    memset(v, 0, size);
+    if(nMEM_TRACE_LEVEL < 2)
+      return v;
+    if(FirstEmptyIdx > 0){
+      Idx = FirstEmptyIdx - 1;
+      pPtrs[Idx] = (unsigned long)v;
+      FirstEmptyIdx = pMallocNumber[Idx];
+      pMallocNumber[Idx] = TotalMallocCount;
+    }
+    else if(AMallocLen < MAXNUMMALLOC){
+      Idx = AMallocLen;
+      pPtrs[Idx] = (unsigned long)v;
+      pMallocNumber[Idx] = TotalMallocCount;
+      AMallocLen++;
+    }
+    if(ControlMalloc == TotalMallocCount)
+      StopInControlMalloc();
+    return v;
+  }
+  FatalInternalError(3);
+  return NULL;
+}
+
+
+//  malloc   .     NULL
+//  0  
+void *SGMallocN(size_t size)
+{
+void*         v;
+long          Idx;
+unsigned long ss;
+
+	if(size <= 0){
+    StopInNullSizeMalloc();
+    BadMallocCount++;
+    return NULL;
+  }
+	else{
+    TotalMallocCount++;
+	  v = malloc(size);
+  }
+  if(v){
+    ss = ((*(((unsigned long*)v) - 1))>>2)<<2;
+    TotalMallocMemSize += ss;
+    memset(v, 0, size);
+    if(nMEM_TRACE_LEVEL < 2)
+      return v;
+    if(FirstEmptyIdx > 0){
+      Idx = FirstEmptyIdx - 1;
+      pPtrs[Idx] = (unsigned long)v;
+      FirstEmptyIdx = pMallocNumber[Idx];
+      pMallocNumber[Idx] = TotalMallocCount;
+    }
+    else if(AMallocLen < MAXNUMMALLOC){
+      Idx = AMallocLen;
+      pPtrs[Idx] = (unsigned long)v;
+      pMallocNumber[Idx] = TotalMallocCount;
+      AMallocLen++;
+    }
+    if(ControlMalloc == TotalMallocCount)
+      StopInControlMalloc();
+    return v;
+  }
+  return NULL;
+}
+
+void SGFree(void* address)
+{
+long          i;
+unsigned long ss;
+
+if (!address)
+	return;
+
+	if(address){
+    if(nMEM_TRACE_LEVEL < 2){
+//      ss = ((*(((unsigned long*)address) - 1))>>2)<<2;
+      ss = SG_MSize(address);
+      TotalMallocMemSize -= ss;
+	    free(address);
+	    TotalFreeCount++;
+      return;
+    }
+    for(i = 0; i < AMallocLen; i++){
+      if(pPtrs[i] == (unsigned long)address){
+        pPtrs[i] = 0;
+        pMallocNumber[i] = FirstEmptyIdx;
+        FirstEmptyIdx = i + 1;
+//        ss = ((*(((unsigned long*)address) - 1))>>2)<<2;
+        ss = SG_MSize(address);
+        TotalMallocMemSize -= ss;
+	      free(address);
+	      TotalFreeCount++;
+        return;
+      }
+    }
+    BadFreeCount++;
+    StopInBadPointerFree();
+		return;
+  }
+  BadFreeCount++;
+  StopInBadPointerFree();
+}
+
+//  realloc          
+void *SGRealloc(void *block, size_t size)
+{
+unsigned long ss;
+void*         v;
+long          i;
+
+  if(!size){    //   
+    if(block)   //      -   free
+      SGFree(block);
+    else{       //   -   
+      StopInBadPointerRealloc();
+      FatalInternalError(4);
+    }
+    return NULL;
+  }
+  if(!block)    //   -    -   malloc
+    return SGMalloc(size);
+  //     
+  if(nMEM_TRACE_LEVEL < 2){
+//    ss = ((*(((unsigned long*)block) - 1))>>2)<<2;
+    ss = SG_MSize(block);
+    TotalMallocMemSize -= ss;
+    v = realloc(block, size);
+    if(v){
+      ss = ((*(((unsigned long*)v) - 1))>>2)<<2;
+      ss = SG_MSize(v);
+      TotalMallocMemSize += ss;
+      return v;
+    }
+    FatalInternalError(3);
+    return NULL;
+  }
+  for(i = 0; i < AMallocLen; i++){
+    if(pPtrs[i] == (unsigned long)block)
+      goto next;
+  }
+    StopInBadPointerRealloc();
+  FatalInternalError(5);
+  return NULL;
+next:
+//  ss = ((*(((unsigned long*)block) - 1))>>2)<<2;
+  ss = SG_MSize(block);
+  TotalMallocMemSize -= ss;
+  v = realloc(block, size);
+  if(v){
+    ss = ((*(((unsigned long*)v) - 1))>>2)<<2;
+    ss = SG_MSize(v);
+    TotalMallocMemSize += ss;
+    pPtrs[i] = (unsigned long)v;
+    return v;
+  }
+  FatalInternalError(3);
+  return NULL;
+}
+
+
+
+
+void *SGReallocN(void *block, size_t size)
+{
+unsigned long ss;
+void*         v;
+long          i;
+
+  if(!size){    //   
+    if(block)   //      -   free
+      SGFree(block);
+    else{       //   -   
+      BadReAllocCount++;
+      StopInBadPointerRealloc();
+    }
+    return NULL;
+  }
+  if(!block)    //   -    -   malloc
+    return SGMalloc(size);
+  //     
+  if(nMEM_TRACE_LEVEL < 2){
+    ss = ((*(((unsigned long*)block) - 1))>>2)<<2;
+    TotalMallocMemSize -= ss;
+    v = realloc(block, size);
+    if(v){
+      ss = ((*(((unsigned long*)v) - 1))>>2)<<2;
+      TotalMallocMemSize += ss;
+    }
+    return v;
+  }
+  for(i = 0; i < AMallocLen; i++){
+    if(pPtrs[i] == (unsigned long)block)
+      goto next;
+  }
+  //   -  .  NULL
+  StopInBadPointerRealloc();
+  BadReAllocCount++;
+  return NULL;
+next:
+  ss = ((*(((unsigned long*)block) - 1))>>2)<<2;
+  TotalMallocMemSize -= ss;
+  v = realloc(block, size);
+  if(v){
+    ss = ((*(((unsigned long*)v) - 1))>>2)<<2;
+    TotalMallocMemSize += ss;
+    pPtrs[i] = (unsigned long)v;
+  }
+  return v;
+}
+
+void InitDbgMem(void)
+{
+  if(nMEM_TRACE_LEVEL < 2)
+    return;
+	pPtrs = (unsigned long*)malloc(MAXNUMMALLOC*sizeof(unsigned long));
+	pMallocNumber = (unsigned long*)malloc(MAXNUMMALLOC*sizeof(unsigned long));
+  if(!pPtrs || !pMallocNumber)
+    nMEM_TRACE_LEVEL = 1;
+}
+
+void FreeDbgMem(void)
+{
+  if(pPtrs)
+    free(pPtrs);
+  pPtrs = NULL;
+  if(pMallocNumber)
+    free(pMallocNumber);
+  pMallocNumber = NULL;
+}
+
+#include <IOSTREAM>
+
+bool        show_memory_leaks=true;
+
+void vReport(void)
+{
+  if(nMEM_TRACE_LEVEL < 1)
+    return;
+  {
+  char buf[100];
+  long i;
+
+    ControlMalloc = 0;
+    for(i = 0; i < AMallocLen; i++){
+      if(pPtrs[i]){
+        ControlMalloc = pMallocNumber[i];
+        break;
+      }
+    }
+    if(TotalMallocCount != TotalFreeCount ||
+      BadMallocCount != 0  ||
+      BadFreeCount != 0    ||
+      BadReAllocCount != 0 ||
+      ControlMalloc != 0
+    )
+	{
+			if (show_memory_leaks)
+			{
+					if(TotalMallocCount != TotalFreeCount)
+					{
+						int j=0;
+						j=sprintf(buf," Non free objects count:  %ld", TotalMallocCount-TotalFreeCount);
+						sprintf(buf + j,"\r\n Non free memory size : %ld bytes", TotalMallocMemSize+126);
+					#if (SG_CURRENT_PLATFORM==SG_PLATFORM_WINDOWS)
+					  	MessageBox(NULL, buf, "MEMORY LEAK",MB_OK|MB_ICONERROR) ;
+					#endif
+                        
+                    #if (SG_CURRENT_PLATFORM==SG_PLATFORM_IOS)
+                        fprintf(stderr,"sgCore MEMORY LEAK - %s\n", buf);
+                    #endif
+					}
+					else
+					{
+						assert(0);
+					}
+			}
+
+    }
+    FreeDbgMem();
+  }
+}
+
+#pragma argsused
+void FatalInternalError(int code)
+//      Main.    
+{
+char Buf[256];
+
+  strcpy(Buf, "Fatal internal error");
+//  MessageBox(NULL, Buf, GetSystemName(), MB_OK|MB_ICONERROR);
+	exit(code);
+}
+