--- psiconv/trunk/lib/psiconv/generate_simple.c	2004/02/25 20:57:10	231
+++ psiconv/trunk/lib/psiconv/generate_simple.c	2004/02/26 15:58:48	232
@@ -38,84 +38,145 @@
 int psiconv_write_u8(const psiconv_config config,psiconv_buffer buf,
                      int lev,const psiconv_u8 value)
 {
-  return psiconv_buffer_add(buf,value);
+  int res;
+  psiconv_progress(config,lev,0,"Writing u8");
+  psiconv_debug(config,lev+1,0,"Value: %02x",value);
+  res = psiconv_buffer_add(buf,value);
+  if (res)
+    psiconv_error(config,lev,0,"Out of memory error");
+  return res;
 }
 
 int psiconv_write_u16(const psiconv_config config,psiconv_buffer buf,
                       int lev,const psiconv_u16 value)
 {
   int res;
+  psiconv_progress(config,lev,0,"Writing u16");
+  psiconv_debug(config,lev+1,0,"Value: %04x",value);
   if ((res = psiconv_buffer_add(buf,value & 0xff))) 
-	return res;
-  return psiconv_buffer_add(buf,(value & 0xff00) >> 8);
+    goto ERROR;
+  if ((res = psiconv_buffer_add(buf,(value & 0xff00) >> 8)))
+    goto ERROR;
+ERROR:
+  if (res)
+    psiconv_error(config,lev,0,"Out of memory error");
+  return res;
 }
 
 int psiconv_write_u32(const psiconv_config config,psiconv_buffer buf,
                       int lev,const psiconv_u32 value)
 {
   int res;
+  psiconv_progress(config,lev,0,"Writing u32");
+  psiconv_debug(config,lev+1,0,"Value: %08x",value);
+
   if ((res = psiconv_buffer_add(buf,value & 0xff))) 
-	return res;
+    goto ERROR;
   if ((res = psiconv_buffer_add(buf,(value & 0xff00) >> 8))) 
-	return res;
+    goto ERROR;
   if ((res = psiconv_buffer_add(buf,(value & 0xff0000) >> 16))) 
-	return res;
-  return psiconv_buffer_add(buf,(value & 0xff000000) >> 24);
+    goto ERROR;
+  if ((res = psiconv_buffer_add(buf,(value & 0xff000000) >> 24)))
+    goto ERROR;
+ERROR:
+  if (res)
+    psiconv_error(config,lev,0,"Out of memory error");
+  return res;
 }
 
 int psiconv_write_S(const psiconv_config config,psiconv_buffer buf, 
                     int lev,const psiconv_u32 value)
 {
+  int res;
+
   psiconv_progress(config,lev,0,"Writing S");
+  psiconv_debug(config,lev+1,0,"Value: %08x",value);
   if (value < 0x40) 
-    return psiconv_write_u8(config,buf,lev+1,value * 4 + 2);
+    res = psiconv_write_u8(config,buf,lev+2,value * 4 + 2);
   else if (value < 0x2000) 
-    return psiconv_write_u16(config,buf,lev+1,value * 8 + 3);
+    res = psiconv_write_u16(config,buf,lev+2,value * 8 + 3);
   else {
     psiconv_error(config,0,psiconv_buffer_length(buf),
                  "Don't know how to write S value larger than 0x2000 "
                  "(trying %x)",value);
-    return -PSICONV_E_GENERATE;
+    res = -PSICONV_E_GENERATE;
   }
+  if (res)
+    psiconv_error(config,lev,0,"Writing of S failed");
+  else
+    psiconv_progress(config,lev,0,"End of S");
+  return res;
 }
 
 int psiconv_write_X(const psiconv_config config,psiconv_buffer buf,
                     int lev, const psiconv_u32 value)
 {
+  int res;
   psiconv_progress(config,lev,0,"Writing X");
+  psiconv_debug(config,lev+1,0,"Value: %08x",value);
   if (value < 0x80) 
-    return psiconv_write_u8(config,buf,lev+1,value * 2);
+    res = psiconv_write_u8(config,buf,lev+2,value * 2);
   else if (value < 0x4000) 
-    return psiconv_write_u16(config,buf,lev+1,value * 4 + 1);
+    res = psiconv_write_u16(config,buf,lev+2,value * 4 + 1);
   else if (value < 0x20000000) 
-    return psiconv_write_u16(config,buf,lev+1,value * 8 + 3);
+    res = psiconv_write_u16(config,buf,lev+2,value * 8 + 3);
   else {
-    psiconv_error(config,0,psiconv_buffer_length(buf),
+    psiconv_error(config,lev,0,
                  "Don't know how to write X value larger than 0x20000000 "
                  "(trying %x)",value);
-    return -PSICONV_E_GENERATE;
+    res = -PSICONV_E_GENERATE;
   }
+  if (res)
+    psiconv_error(config,lev,0,"Writing of X failed");
+  else
+    psiconv_progress(config,lev,0,"End of X");
+  return res;
 }
 
 int psiconv_write_length(const psiconv_config config,psiconv_buffer buf, 
                          int lev,const psiconv_length_t value)
 {
-  return psiconv_write_u32(config,buf,lev+1,value * (1440.0/2.54) + 0.5);
+  int res;
+  psiconv_progress(config,lev,0,"Writing length");
+  psiconv_debug(config,lev+1,0,"Value: %f",value);
+  res = psiconv_write_u32(config,buf,lev+2,value * (1440.0/2.54) + 0.5);
+  if (res)
+    psiconv_error(config,lev,0,"Writing of length failed");
+  else
+    psiconv_progress(config,lev,0,"End of length");
+  return res;
 }
 
 int psiconv_write_size(const psiconv_config config,psiconv_buffer buf,
                        int lev, psiconv_size_t value)
 {
-  return psiconv_write_u32(config,buf,lev+1,value * 20.0 + 0.5);
+  int res;
+  psiconv_progress(config,lev,0,"Writing size");
+  psiconv_debug(config,lev+1,0,"Value: %f",value);
+  res = psiconv_write_u32(config,buf,lev+2,value * 20.0 + 0.5);
+  if (res)
+    psiconv_error(config,lev,0,"Writing of size failed");
+  else
+    psiconv_progress(config,lev,0,"End of size");
+  return res;
 }
 
 int psiconv_write_bool(const psiconv_config config,psiconv_buffer buf, 
                        int lev,const psiconv_bool_t value)
 {
+  int res;
+  psiconv_progress(config,lev,0,"Writing bool");
+  psiconv_debug(config,lev+1,0,"Value: %s",
+                value == psiconv_bool_false?"False":"True");
   if ((value != psiconv_bool_true) && (value != psiconv_bool_false)) 
     psiconv_warn(config,0,psiconv_buffer_length(buf),
-                 "Boolean has non-enum value (found %d)",value);
-  return psiconv_write_u8(config,buf,lev+1,value == psiconv_bool_false?0:1);
+                 "Boolean has non-enum value (found %d, used true)",value);
+  res = psiconv_write_u8(config,buf,lev+2,value == psiconv_bool_false?0:1);
+  if (res)
+    psiconv_error(config,lev,0,"Writing of bool failed");
+  else
+    psiconv_progress(config,lev,0,"End of bool");
+  return res;
 }
 
 int psiconv_write_string(const psiconv_config config,psiconv_buffer buf,
@@ -162,23 +223,32 @@
                              int lev, const psiconv_string_t value,int kind)
 {
   int res,i,len;
+  char *printable;
 
   len = psiconv_unicode_strlen(value);
   if (!value) {
     psiconv_error(config,lev,0, "NULL string");
     return -PSICONV_E_GENERATE;
   }
+
+  if (!(printable = psiconv_make_printable(config,value))) {
+    psiconv_error(config,lev,0,"Out of memory error");
+    return -PSICONV_E_NOMEM;
+  }
+  psiconv_debug(config,lev+1,0,"Value: %s",printable);
+  free(printable);
+
   if (kind == -1) 
-    res = psiconv_write_S(config,buf,lev+1,len);
+    res = psiconv_write_S(config,buf,lev+2,len);
   else if (kind == -2)
-    res = psiconv_write_u8(config,buf,lev+1,len);
+    res = psiconv_write_u8(config,buf,lev+2,len);
   else
     res = 0;
   if (res)
     return res;
 
   for (i = 0; i < len; i++) 
-    if ((res = psiconv_unicode_write_char(config,buf,lev+1,value[i]))) 
+    if ((res = psiconv_unicode_write_char(config,buf,lev+2,value[i]))) 
       return res;
   return -PSICONV_E_OK;
 }
@@ -186,5 +256,11 @@
 int psiconv_write_offset(const psiconv_config config,psiconv_buffer buf, 
                          int lev,psiconv_u32 id)
 {
-  return psiconv_buffer_add_reference(buf,id);
+  int res;
+  psiconv_progress(config,lev,0,"Writing offset");
+  psiconv_debug(config,lev+1,0,"ID: %08x",id);
+  res = psiconv_buffer_add_reference(buf,id);
+  if (res)
+    psiconv_error(config,lev,0,"Out of memory error");
+  return res;
 }