lib/psiconv/generate_driver.c

/*
    generate_driver.c - Part of psiconv, a PSION 5 file formats converter
    Copyright (c) 2000-2004  Frodo Looijaard <frodol@dds.nl>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include "config.h"
#include "compat.h"

#include <stdlib.h>

#include "error.h"
#include "generate_routines.h"

#ifdef DMALLOC
#include <dmalloc.h>
#endif

static psiconv_ucs2 unicode_paint[10] = { 'P','a','i','n','t','.','a','p','p',0 };
static psiconv_ucs2 unicode_texted[11] ={ 'T','e','x','t','E','d','.','a','p','p',0 };
static psiconv_ucs2 unicode_word[9] =   { 'W','o','r','d','.','a','p','p',0 };
                                                                                

int psiconv_write(const psiconv_config config, psiconv_buffer *buf,
                  const psiconv_file value)
{
  int res;
  int lev = 0;

  if (!value) {
    psiconv_error(config,0,0,"Can't parse to an empty buffer!");
    return -PSICONV_E_OTHER;
  }
  if (!(*buf = psiconv_buffer_new()))
    return -PSICONV_E_NOMEM;

  if (value->type == psiconv_word_file) {
    if ((res = psiconv_write_header_section(config,*buf,lev+1,PSICONV_ID_PSION5,
                                            PSICONV_ID_DATA_FILE,
                                            PSICONV_ID_WORD)))
      goto ERROR;
    if ((res =psiconv_write_word_file(config,*buf,lev+1,(psiconv_word_f) (value->file))))
      goto ERROR;
  } else if (value->type == psiconv_texted_file) {
    if ((res = psiconv_write_header_section(config,*buf,lev+1,PSICONV_ID_PSION5,
                                            PSICONV_ID_DATA_FILE,
                                            PSICONV_ID_TEXTED)))
      goto ERROR;
    if ((res =psiconv_write_texted_file(config,*buf,lev+1,
                                           (psiconv_texted_f) (value->file))))
      goto ERROR;
  } else if (value->type == psiconv_sketch_file) {
    if ((res = psiconv_write_header_section(config,*buf,lev+1,PSICONV_ID_PSION5,
                                            PSICONV_ID_DATA_FILE,
                                            PSICONV_ID_SKETCH)))
      goto ERROR;
    if ((res =psiconv_write_sketch_file(config,*buf,lev+1,
                                           (psiconv_sketch_f) (value->file))))
      goto ERROR;
  } else if (value->type == psiconv_mbm_file) {
    if ((res = psiconv_write_header_section(config,*buf,lev+1,PSICONV_ID_PSION5,
                                            PSICONV_ID_MBM_FILE,
                                            0x00000000)))
      goto ERROR;
    if ((res =psiconv_write_mbm_file(config,*buf,lev+1,
                                           (psiconv_mbm_f) (value->file))))
      goto ERROR;
  } else if (value->type == psiconv_clipart_file) {
    /* No complete header section, so we do it all in the below function */
    if ((res =psiconv_write_clipart_file(config,*buf,lev+1,
                                           (psiconv_clipart_f) (value->file))))
      goto ERROR;
  } else {
    psiconv_error(config,0,0,"Unknown or unsupported file type");
    res = -PSICONV_E_GENERATE;
    goto ERROR;
  }
  if ((res = psiconv_buffer_resolve(*buf)))
    goto ERROR;
  return -PSICONV_E_OK;

ERROR:
  psiconv_buffer_free(*buf);
  return res;
}
  
int psiconv_write_texted_file(const psiconv_config config,
                              psiconv_buffer buf,int lev,psiconv_texted_f value)
{
  psiconv_character_layout base_char;
  psiconv_paragraph_layout base_para;
  int res;
  psiconv_section_table_section section_table;
  psiconv_section_table_entry entry;
  psiconv_u32 section_table_id;
  psiconv_buffer buf_texted;

  psiconv_progress(config,lev,0,"Writing texted file");
  if (!value) {
    psiconv_error(config,lev,0,"Null TextEd file");
    res = -PSICONV_E_GENERATE;
    goto ERROR1;
  }

  if (!(section_table = psiconv_list_new(sizeof(*entry)))) {
    res = -PSICONV_E_NOMEM;
    goto ERROR1;
  }

  if (!(entry = malloc(sizeof(*entry)))) {
    res = -PSICONV_E_NOMEM;
    goto ERROR2;
  }
    
  if (!(base_char = psiconv_basic_character_layout())) {
    res = -PSICONV_E_NOMEM;
    goto ERROR3;
  }
  if (!(base_para = psiconv_basic_paragraph_layout())) {
    res = -PSICONV_E_NOMEM;
    goto ERROR4;
  }

  section_table_id = psiconv_buffer_unique_id();
  if ((res = psiconv_write_offset(config,buf,lev+1,section_table_id)))
    goto ERROR5;

  entry->id = PSICONV_ID_APPL_ID_SECTION;
  entry->offset = psiconv_buffer_unique_id();
  if ((res = psiconv_list_add(section_table,entry)))
    goto ERROR5;
  if ((res = psiconv_buffer_add_target(buf,entry->offset)))
    goto ERROR5;
  if ((res=psiconv_write_application_id_section(config,buf,lev+1,
                                           PSICONV_ID_TEXTED,unicode_texted)))
    goto ERROR5;
  
  entry->id = PSICONV_ID_PAGE_LAYOUT_SECTION;
  entry->offset = psiconv_buffer_unique_id();
  if ((res = psiconv_list_add(section_table,entry)))
    goto ERROR5;
  if ((res = psiconv_buffer_add_target(buf,entry->offset)))
    goto ERROR5;
  if ((res = psiconv_write_page_layout_section(config,buf,lev+1,value->page_sec)))
    goto ERROR5;

  entry->id = PSICONV_ID_TEXTED;
  entry->offset = psiconv_buffer_unique_id();
  if ((res = psiconv_list_add(section_table,entry)))
    goto ERROR5;
  if ((res = psiconv_buffer_add_target(buf,entry->offset)))
    goto ERROR5;
  if ((res = psiconv_write_texted_section(config,buf,lev+1,value->texted_sec,
                                           base_char,base_para,&buf_texted)))
    goto ERROR5;

  if ((res = psiconv_buffer_concat(buf,buf_texted)))
    goto ERROR6;


  if ((res = psiconv_buffer_add_target(buf,section_table_id)))
    goto ERROR6;

  res = psiconv_write_section_table_section(config,buf,lev+1,section_table);
  
ERROR6:
  psiconv_buffer_free(buf_texted);
ERROR5:
  psiconv_free_paragraph_layout(base_para);
ERROR4:
  psiconv_free_character_layout(base_char);
ERROR3:
  free(entry);
ERROR2:
  psiconv_list_free(section_table);
ERROR1:
  if (res)
    psiconv_error(config,lev,0,"Writing of texted file failed");
  else
    psiconv_progress(config,lev,0,"End of texted file");
  return res;
}

int psiconv_write_word_file(const psiconv_config config,
                            psiconv_buffer buf,int lev,psiconv_word_f value)
{
  int res;
  psiconv_section_table_section section_table;
  psiconv_section_table_entry entry;
  psiconv_u32 section_table_id;

  psiconv_progress(config,lev,0,"Writing word file");
  if (!value) {
    psiconv_error(config,lev,0,"Null Word file");
    res = -PSICONV_E_GENERATE;
    goto ERROR1;
  }

  if (!(section_table = psiconv_list_new(sizeof(*entry)))) {
    res = -PSICONV_E_NOMEM;
    goto ERROR1;
  }

  if (!(entry = malloc(sizeof(*entry)))) {
    res = -PSICONV_E_NOMEM;
    goto ERROR2;
  }
    
  section_table_id = psiconv_buffer_unique_id();
  if ((res = psiconv_write_offset(config,buf,lev+1,section_table_id)))
    goto ERROR3;

  entry->id = PSICONV_ID_APPL_ID_SECTION;
  entry->offset = psiconv_buffer_unique_id();
  if ((res = psiconv_list_add(section_table,entry)))
    goto ERROR3;
  if ((res = psiconv_buffer_add_target(buf,entry->offset)))
    goto ERROR3;
  if ((res=psiconv_write_application_id_section(config,buf,lev+1,
                                           PSICONV_ID_WORD,unicode_word)))
    goto ERROR3;
  
  entry->id = PSICONV_ID_WORD_STATUS_SECTION;
  entry->offset = psiconv_buffer_unique_id();
  if ((res = psiconv_list_add(section_table,entry)))
    goto ERROR3;
  if ((res = psiconv_buffer_add_target(buf,entry->offset)))
    goto ERROR3;
  if ((res = psiconv_write_word_status_section(config,buf,lev+1,value->status_sec)))
    goto ERROR3;

  entry->id = PSICONV_ID_PAGE_LAYOUT_SECTION;
  entry->offset = psiconv_buffer_unique_id();
  if ((res = psiconv_list_add(section_table,entry)))
    goto ERROR3;
  if ((res = psiconv_buffer_add_target(buf,entry->offset)))
    goto ERROR3;
  if ((res = psiconv_write_page_layout_section(config,buf,lev+1,value->page_sec)))
    goto ERROR3;

  entry->id = PSICONV_ID_WORD_STYLES_SECTION;
  entry->offset = psiconv_buffer_unique_id();
  if ((res = psiconv_list_add(section_table,entry)))
    goto ERROR3;
  if ((res = psiconv_buffer_add_target(buf,entry->offset)))
    goto ERROR3;
  if ((res = psiconv_write_word_styles_section(config,buf,lev+1,value->styles_sec)))
    goto ERROR3;

  entry->id = PSICONV_ID_TEXT_SECTION;
  entry->offset = psiconv_buffer_unique_id();
  if ((res = psiconv_list_add(section_table,entry)))
    goto ERROR3;
  if ((res = psiconv_buffer_add_target(buf,entry->offset)))
    goto ERROR3;
  if ((res = psiconv_write_text_section(config,buf,lev+1,value->paragraphs)))
    goto ERROR3;

  entry->id = PSICONV_ID_LAYOUT_SECTION;
  entry->offset = psiconv_buffer_unique_id();
  if ((res = psiconv_list_add(section_table,entry)))
    goto ERROR3;
  if ((res = psiconv_buffer_add_target(buf,entry->offset)))
    goto ERROR3;
  if ((res = psiconv_write_styled_layout_section(config,buf,lev+1,value->paragraphs,
                                                 value->styles_sec)))
    goto ERROR3;

  if ((res = psiconv_buffer_add_target(buf,section_table_id)))
    goto ERROR3;

  res = psiconv_write_section_table_section(config,buf,lev+1,section_table);
  
ERROR3:
  free(entry);
ERROR2:
  psiconv_list_free(section_table);
ERROR1:
  if (res)
    psiconv_error(config,lev,0,"Writing of word file failed");
  else
    psiconv_progress(config,lev,0,"End of word file");
  return res;
}

int psiconv_write_sketch_file(const psiconv_config config,
                              psiconv_buffer buf,int lev,psiconv_sketch_f value)
{
  int res;
  psiconv_section_table_section section_table;
  psiconv_section_table_entry entry;
  psiconv_u32 section_table_id;

  psiconv_progress(config,lev,0,"Writing sketch file");
  if (!value) {
    psiconv_error(config,lev,0,"Null Sketch file");
    res = -PSICONV_E_GENERATE;
    goto ERROR1;
  }

  if (!(section_table = psiconv_list_new(sizeof(*entry)))) {
    res = -PSICONV_E_NOMEM;
    goto ERROR1;
  }

  if (!(entry = malloc(sizeof(*entry)))) {
    res = -PSICONV_E_NOMEM;
    goto ERROR2;
  }
    
  section_table_id = psiconv_buffer_unique_id();
  if ((res = psiconv_write_offset(config,buf,lev+1,section_table_id)))
    goto ERROR3;

  entry->id = PSICONV_ID_APPL_ID_SECTION;
  entry->offset = psiconv_buffer_unique_id();
  if ((res = psiconv_list_add(section_table,entry)))
    goto ERROR3;
  if ((res = psiconv_buffer_add_target(buf,entry->offset)))
    goto ERROR3;
  if ((res=psiconv_write_application_id_section(config,buf,lev+1,
                                           PSICONV_ID_SKETCH,unicode_paint)))
    goto ERROR3;
  
  entry->id = PSICONV_ID_SKETCH_SECTION;
  entry->offset = psiconv_buffer_unique_id();
  if ((res = psiconv_list_add(section_table,entry)))
    goto ERROR3;
  if ((res = psiconv_buffer_add_target(buf,entry->offset)))
    goto ERROR3;
  if ((res = psiconv_write_sketch_section(config,buf,lev+1,value->sketch_sec)))
    goto ERROR3;

  if ((res = psiconv_buffer_add_target(buf,section_table_id)))
    goto ERROR3;
  res = psiconv_write_section_table_section(config,buf,lev+1,section_table);
  
ERROR3:
  free(entry);
ERROR2:
  psiconv_list_free(section_table);
ERROR1:
  if (res)
    psiconv_error(config,lev,0,"Writing of sketch file failed");
  else
    psiconv_progress(config,lev,0,"End of sketch file");
  return res;
}

int psiconv_write_mbm_file(const psiconv_config config,
                           psiconv_buffer buf,int lev,psiconv_mbm_f value)
{
  int res,i;
  psiconv_jumptable_section jumptable;
  psiconv_u32 *entry,id,table_id;
  psiconv_paint_data_section section;

  psiconv_progress(config,lev,0,"Writing mbm file");
  if (!value) {
    psiconv_error(config,lev,0,"Null MBM file");
    res = -PSICONV_E_GENERATE;
    goto ERROR1;
  }

  if (!(jumptable = psiconv_list_new(sizeof(*entry)))) {
    res = -PSICONV_E_NOMEM;
    goto ERROR1;
  }

  table_id = psiconv_buffer_unique_id();
  if ((res = psiconv_buffer_add_reference(buf,table_id)))
    goto ERROR2;
  
  for (i = 0; i < psiconv_list_length(value->sections); i++) {
    if (!(section = psiconv_list_get(value->sections,i))) {
      psiconv_error(config,lev,0,"Massive memory corruption");
      res = -PSICONV_E_NOMEM;
      goto ERROR2;
    }
    id = psiconv_buffer_unique_id();
    psiconv_list_add(jumptable,&id);
    if ((res = psiconv_buffer_add_target(buf,id)))
      goto ERROR2;
    if ((res = psiconv_write_paint_data_section(config,buf,lev+1,section,0)))
      goto ERROR2;
  }

  if ((res = psiconv_buffer_add_target(buf,table_id)))
    goto ERROR2;
  if ((res = psiconv_write_jumptable_section(config,buf,lev+1,jumptable)))
    goto ERROR2;
    
  
ERROR2:
  psiconv_list_free(jumptable);
ERROR1:
  if (res)
    psiconv_error(config,lev,0,"Writing of mbm file failed");
  else
    psiconv_progress(config,lev,0,"End of mbm file");
  return res;
}

/* Note: this file is special, because it does not have a complete header! */
int psiconv_write_clipart_file(const psiconv_config config,
                           psiconv_buffer buf,int lev,psiconv_clipart_f value)
{
  int res,i;
  psiconv_jumptable_section jumptable;
  psiconv_u32 *entry,id;
  psiconv_clipart_section section;
  psiconv_buffer sec_buf;

  psiconv_progress(config,lev,0,"Writing clipart file");
  if (!value) {
    psiconv_error(config,lev,0,"Null Clipart file");
    res = -PSICONV_E_GENERATE;
    goto ERROR1;
  }

  if (!(jumptable = psiconv_list_new(sizeof(*entry)))) {
    res = -PSICONV_E_NOMEM;
    goto ERROR1;
  }

  if (!(sec_buf = psiconv_buffer_new())) {
    res = -PSICONV_E_NOMEM;
    goto ERROR2;
  }

  if ((res = psiconv_write_u32(config,buf,lev+1,PSICONV_ID_CLIPART)))
    goto ERROR3;

  for (i = 0; i < psiconv_list_length(value->sections); i++) {
    if (!(section = psiconv_list_get(value->sections,i))) {
      psiconv_error(config,lev,0,"Massive memory corruption");
      res = -PSICONV_E_NOMEM;
      goto ERROR3;
    }
    id = psiconv_buffer_unique_id();
    psiconv_list_add(jumptable,&id);
    if ((res = psiconv_buffer_add_target(sec_buf,id)))
      goto ERROR3;
    if ((res = psiconv_write_clipart_section(config,sec_buf, lev+1,section)))
      goto ERROR3;
  }

  if ((res = psiconv_write_jumptable_section(config,buf,lev+1,jumptable)))
    goto ERROR3;

  if ((res = psiconv_buffer_concat(buf,sec_buf)))
    goto ERROR3;
    
  
ERROR3:
  psiconv_buffer_free(sec_buf);
ERROR2:
  psiconv_list_free(jumptable);
ERROR1:
  if (res)
    psiconv_error(config,lev,0,"Writing of clipart file failed");
  else
    psiconv_progress(config,lev,0,"End of clipart file");
  return res;
}
1	/*
2	generate_driver.c - Part of psiconv, a PSION 5 file formats converter
3	Copyright (c) 2000-2004 Frodo Looijaard <frodol@dds.nl>
4
5	This program is free software; you can redistribute it and/or modify
6	it under the terms of the GNU General Public License as published by
7	the Free Software Foundation; either version 2 of the License, or
8	(at your option) any later version.
9
10	This program is distributed in the hope that it will be useful,
11	but WITHOUT ANY WARRANTY; without even the implied warranty of
12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	GNU General Public License for more details.
14
15	You should have received a copy of the GNU General Public License
16	along with this program; if not, write to the Free Software
17	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18	*/
19
20	#include "config.h"
21	#include "compat.h"
22
23	#include <stdlib.h>
24
25	#include "error.h"
26	#include "generate_routines.h"
27
28	#ifdef DMALLOC
29	#include <dmalloc.h>
30	#endif
31
32	static psiconv_ucs2 unicode_paint[10] = { 'P','a','i','n','t','.','a','p','p',0 };
33	static psiconv_ucs2 unicode_texted[11] ={ 'T','e','x','t','E','d','.','a','p','p',0 };
34	static psiconv_ucs2 unicode_word[9] = { 'W','o','r','d','.','a','p','p',0 };
35
36
37	int psiconv_write(const psiconv_config config, psiconv_buffer *buf,
38	const psiconv_file value)
39	{
40	int res;
41	int lev = 0;
42
43	if (!value) {
44	psiconv_error(config,0,0,"Can't parse to an empty buffer!");
45	return -PSICONV_E_OTHER;
46	}
47	if (!(*buf = psiconv_buffer_new()))
48	return -PSICONV_E_NOMEM;
49
50	if (value->type == psiconv_word_file) {
51	if ((res = psiconv_write_header_section(config,*buf,lev+1,PSICONV_ID_PSION5,
52	PSICONV_ID_DATA_FILE,
53	PSICONV_ID_WORD)))
54	goto ERROR;
55	if ((res =psiconv_write_word_file(config,*buf,lev+1,(psiconv_word_f) (value->file))))
56	goto ERROR;
57	} else if (value->type == psiconv_texted_file) {
58	if ((res = psiconv_write_header_section(config,*buf,lev+1,PSICONV_ID_PSION5,
59	PSICONV_ID_DATA_FILE,
60	PSICONV_ID_TEXTED)))
61	goto ERROR;
62	if ((res =psiconv_write_texted_file(config,*buf,lev+1,
63	(psiconv_texted_f) (value->file))))
64	goto ERROR;
65	} else if (value->type == psiconv_sketch_file) {
66	if ((res = psiconv_write_header_section(config,*buf,lev+1,PSICONV_ID_PSION5,
67	PSICONV_ID_DATA_FILE,
68	PSICONV_ID_SKETCH)))
69	goto ERROR;
70	if ((res =psiconv_write_sketch_file(config,*buf,lev+1,
71	(psiconv_sketch_f) (value->file))))
72	goto ERROR;
73	} else if (value->type == psiconv_mbm_file) {
74	if ((res = psiconv_write_header_section(config,*buf,lev+1,PSICONV_ID_PSION5,
75	PSICONV_ID_MBM_FILE,
76	0x00000000)))
77	goto ERROR;
78	if ((res =psiconv_write_mbm_file(config,*buf,lev+1,
79	(psiconv_mbm_f) (value->file))))
80	goto ERROR;
81	} else if (value->type == psiconv_clipart_file) {
82	/* No complete header section, so we do it all in the below function */
83	if ((res =psiconv_write_clipart_file(config,*buf,lev+1,
84	(psiconv_clipart_f) (value->file))))
85	goto ERROR;
86	} else {
87	psiconv_error(config,0,0,"Unknown or unsupported file type");
88	res = -PSICONV_E_GENERATE;
89	goto ERROR;
90	}
91	if ((res = psiconv_buffer_resolve(*buf)))
92	goto ERROR;
93	return -PSICONV_E_OK;
94
95	ERROR:
96	psiconv_buffer_free(*buf);
97	return res;
98	}
99
100	int psiconv_write_texted_file(const psiconv_config config,
101	psiconv_buffer buf,int lev,psiconv_texted_f value)
102	{
103	psiconv_character_layout base_char;
104	psiconv_paragraph_layout base_para;
105	int res;
106	psiconv_section_table_section section_table;
107	psiconv_section_table_entry entry;
108	psiconv_u32 section_table_id;
109	psiconv_buffer buf_texted;
110
111	psiconv_progress(config,lev,0,"Writing texted file");
112	if (!value) {
113	psiconv_error(config,lev,0,"Null TextEd file");
114	res = -PSICONV_E_GENERATE;
115	goto ERROR1;
116	}
117
118	if (!(section_table = psiconv_list_new(sizeof(*entry)))) {
119	res = -PSICONV_E_NOMEM;
120	goto ERROR1;
121	}
122
123	if (!(entry = malloc(sizeof(*entry)))) {
124	res = -PSICONV_E_NOMEM;
125	goto ERROR2;
126	}
127
128	if (!(base_char = psiconv_basic_character_layout())) {
129	res = -PSICONV_E_NOMEM;
130	goto ERROR3;
131	}
132	if (!(base_para = psiconv_basic_paragraph_layout())) {
133	res = -PSICONV_E_NOMEM;
134	goto ERROR4;
135	}
136
137	section_table_id = psiconv_buffer_unique_id();
138	if ((res = psiconv_write_offset(config,buf,lev+1,section_table_id)))
139	goto ERROR5;
140
141	entry->id = PSICONV_ID_APPL_ID_SECTION;
142	entry->offset = psiconv_buffer_unique_id();
143	if ((res = psiconv_list_add(section_table,entry)))
144	goto ERROR5;
145	if ((res = psiconv_buffer_add_target(buf,entry->offset)))
146	goto ERROR5;
147	if ((res=psiconv_write_application_id_section(config,buf,lev+1,
148	PSICONV_ID_TEXTED,unicode_texted)))
149	goto ERROR5;
150
151	entry->id = PSICONV_ID_PAGE_LAYOUT_SECTION;
152	entry->offset = psiconv_buffer_unique_id();
153	if ((res = psiconv_list_add(section_table,entry)))
154	goto ERROR5;
155	if ((res = psiconv_buffer_add_target(buf,entry->offset)))
156	goto ERROR5;
157	if ((res = psiconv_write_page_layout_section(config,buf,lev+1,value->page_sec)))
158	goto ERROR5;
159
160	entry->id = PSICONV_ID_TEXTED;
161	entry->offset = psiconv_buffer_unique_id();
162	if ((res = psiconv_list_add(section_table,entry)))
163	goto ERROR5;
164	if ((res = psiconv_buffer_add_target(buf,entry->offset)))
165	goto ERROR5;
166	if ((res = psiconv_write_texted_section(config,buf,lev+1,value->texted_sec,
167	base_char,base_para,&buf_texted)))
168	goto ERROR5;
169
170	if ((res = psiconv_buffer_concat(buf,buf_texted)))
171	goto ERROR6;
172
173
174	if ((res = psiconv_buffer_add_target(buf,section_table_id)))
175	goto ERROR6;
176
177	res = psiconv_write_section_table_section(config,buf,lev+1,section_table);
178
179	ERROR6:
180	psiconv_buffer_free(buf_texted);
181	ERROR5:
182	psiconv_free_paragraph_layout(base_para);
183	ERROR4:
184	psiconv_free_character_layout(base_char);
185	ERROR3:
186	free(entry);
187	ERROR2:
188	psiconv_list_free(section_table);
189	ERROR1:
190	if (res)
191	psiconv_error(config,lev,0,"Writing of texted file failed");
192	else
193	psiconv_progress(config,lev,0,"End of texted file");
194	return res;
195	}
196
197	int psiconv_write_word_file(const psiconv_config config,
198	psiconv_buffer buf,int lev,psiconv_word_f value)
199	{
200	int res;
201	psiconv_section_table_section section_table;
202	psiconv_section_table_entry entry;
203	psiconv_u32 section_table_id;
204
205	psiconv_progress(config,lev,0,"Writing word file");
206	if (!value) {
207	psiconv_error(config,lev,0,"Null Word file");
208	res = -PSICONV_E_GENERATE;
209	goto ERROR1;
210	}
211
212	if (!(section_table = psiconv_list_new(sizeof(*entry)))) {
213	res = -PSICONV_E_NOMEM;
214	goto ERROR1;
215	}
216
217	if (!(entry = malloc(sizeof(*entry)))) {
218	res = -PSICONV_E_NOMEM;
219	goto ERROR2;
220	}
221
222	section_table_id = psiconv_buffer_unique_id();
223	if ((res = psiconv_write_offset(config,buf,lev+1,section_table_id)))
224	goto ERROR3;
225
226	entry->id = PSICONV_ID_APPL_ID_SECTION;
227	entry->offset = psiconv_buffer_unique_id();
228	if ((res = psiconv_list_add(section_table,entry)))
229	goto ERROR3;
230	if ((res = psiconv_buffer_add_target(buf,entry->offset)))
231	goto ERROR3;
232	if ((res=psiconv_write_application_id_section(config,buf,lev+1,
233	PSICONV_ID_WORD,unicode_word)))
234	goto ERROR3;
235
236	entry->id = PSICONV_ID_WORD_STATUS_SECTION;
237	entry->offset = psiconv_buffer_unique_id();
238	if ((res = psiconv_list_add(section_table,entry)))
239	goto ERROR3;
240	if ((res = psiconv_buffer_add_target(buf,entry->offset)))
241	goto ERROR3;
242	if ((res = psiconv_write_word_status_section(config,buf,lev+1,value->status_sec)))
243	goto ERROR3;
244
245	entry->id = PSICONV_ID_PAGE_LAYOUT_SECTION;
246	entry->offset = psiconv_buffer_unique_id();
247	if ((res = psiconv_list_add(section_table,entry)))
248	goto ERROR3;
249	if ((res = psiconv_buffer_add_target(buf,entry->offset)))
250	goto ERROR3;
251	if ((res = psiconv_write_page_layout_section(config,buf,lev+1,value->page_sec)))
252	goto ERROR3;
253
254	entry->id = PSICONV_ID_WORD_STYLES_SECTION;
255	entry->offset = psiconv_buffer_unique_id();
256	if ((res = psiconv_list_add(section_table,entry)))
257	goto ERROR3;
258	if ((res = psiconv_buffer_add_target(buf,entry->offset)))
259	goto ERROR3;
260	if ((res = psiconv_write_word_styles_section(config,buf,lev+1,value->styles_sec)))
261	goto ERROR3;
262
263	entry->id = PSICONV_ID_TEXT_SECTION;
264	entry->offset = psiconv_buffer_unique_id();
265	if ((res = psiconv_list_add(section_table,entry)))
266	goto ERROR3;
267	if ((res = psiconv_buffer_add_target(buf,entry->offset)))
268	goto ERROR3;
269	if ((res = psiconv_write_text_section(config,buf,lev+1,value->paragraphs)))
270	goto ERROR3;
271
272	entry->id = PSICONV_ID_LAYOUT_SECTION;
273	entry->offset = psiconv_buffer_unique_id();
274	if ((res = psiconv_list_add(section_table,entry)))
275	goto ERROR3;
276	if ((res = psiconv_buffer_add_target(buf,entry->offset)))
277	goto ERROR3;
278	if ((res = psiconv_write_styled_layout_section(config,buf,lev+1,value->paragraphs,
279	value->styles_sec)))
280	goto ERROR3;
281
282	if ((res = psiconv_buffer_add_target(buf,section_table_id)))
283	goto ERROR3;
284
285	res = psiconv_write_section_table_section(config,buf,lev+1,section_table);
286
287	ERROR3:
288	free(entry);
289	ERROR2:
290	psiconv_list_free(section_table);
291	ERROR1:
292	if (res)
293	psiconv_error(config,lev,0,"Writing of word file failed");
294	else
295	psiconv_progress(config,lev,0,"End of word file");
296	return res;
297	}
298
299	int psiconv_write_sketch_file(const psiconv_config config,
300	psiconv_buffer buf,int lev,psiconv_sketch_f value)
301	{
302	int res;
303	psiconv_section_table_section section_table;
304	psiconv_section_table_entry entry;
305	psiconv_u32 section_table_id;
306
307	psiconv_progress(config,lev,0,"Writing sketch file");
308	if (!value) {
309	psiconv_error(config,lev,0,"Null Sketch file");
310	res = -PSICONV_E_GENERATE;
311	goto ERROR1;
312	}
313
314	if (!(section_table = psiconv_list_new(sizeof(*entry)))) {
315	res = -PSICONV_E_NOMEM;
316	goto ERROR1;
317	}
318
319	if (!(entry = malloc(sizeof(*entry)))) {
320	res = -PSICONV_E_NOMEM;
321	goto ERROR2;
322	}
323
324	section_table_id = psiconv_buffer_unique_id();
325	if ((res = psiconv_write_offset(config,buf,lev+1,section_table_id)))
326	goto ERROR3;
327
328	entry->id = PSICONV_ID_APPL_ID_SECTION;
329	entry->offset = psiconv_buffer_unique_id();
330	if ((res = psiconv_list_add(section_table,entry)))
331	goto ERROR3;
332	if ((res = psiconv_buffer_add_target(buf,entry->offset)))
333	goto ERROR3;
334	if ((res=psiconv_write_application_id_section(config,buf,lev+1,
335	PSICONV_ID_SKETCH,unicode_paint)))
336	goto ERROR3;
337
338	entry->id = PSICONV_ID_SKETCH_SECTION;
339	entry->offset = psiconv_buffer_unique_id();
340	if ((res = psiconv_list_add(section_table,entry)))
341	goto ERROR3;
342	if ((res = psiconv_buffer_add_target(buf,entry->offset)))
343	goto ERROR3;
344	if ((res = psiconv_write_sketch_section(config,buf,lev+1,value->sketch_sec)))
345	goto ERROR3;
346
347	if ((res = psiconv_buffer_add_target(buf,section_table_id)))
348	goto ERROR3;
349	res = psiconv_write_section_table_section(config,buf,lev+1,section_table);
350
351	ERROR3:
352	free(entry);
353	ERROR2:
354	psiconv_list_free(section_table);
355	ERROR1:
356	if (res)
357	psiconv_error(config,lev,0,"Writing of sketch file failed");
358	else
359	psiconv_progress(config,lev,0,"End of sketch file");
360	return res;
361	}
362
363	int psiconv_write_mbm_file(const psiconv_config config,
364	psiconv_buffer buf,int lev,psiconv_mbm_f value)
365	{
366	int res,i;
367	psiconv_jumptable_section jumptable;
368	psiconv_u32 *entry,id,table_id;
369	psiconv_paint_data_section section;
370
371	psiconv_progress(config,lev,0,"Writing mbm file");
372	if (!value) {
373	psiconv_error(config,lev,0,"Null MBM file");
374	res = -PSICONV_E_GENERATE;
375	goto ERROR1;
376	}
377
378	if (!(jumptable = psiconv_list_new(sizeof(*entry)))) {
379	res = -PSICONV_E_NOMEM;
380	goto ERROR1;
381	}
382
383	table_id = psiconv_buffer_unique_id();
384	if ((res = psiconv_buffer_add_reference(buf,table_id)))
385	goto ERROR2;
386
387	for (i = 0; i < psiconv_list_length(value->sections); i++) {
388	if (!(section = psiconv_list_get(value->sections,i))) {
389	psiconv_error(config,lev,0,"Massive memory corruption");
390	res = -PSICONV_E_NOMEM;
391	goto ERROR2;
392	}
393	id = psiconv_buffer_unique_id();
394	psiconv_list_add(jumptable,&id);
395	if ((res = psiconv_buffer_add_target(buf,id)))
396	goto ERROR2;
397	if ((res = psiconv_write_paint_data_section(config,buf,lev+1,section,0)))
398	goto ERROR2;
399	}
400
401	if ((res = psiconv_buffer_add_target(buf,table_id)))
402	goto ERROR2;
403	if ((res = psiconv_write_jumptable_section(config,buf,lev+1,jumptable)))
404	goto ERROR2;
405
406
407	ERROR2:
408	psiconv_list_free(jumptable);
409	ERROR1:
410	if (res)
411	psiconv_error(config,lev,0,"Writing of mbm file failed");
412	else
413	psiconv_progress(config,lev,0,"End of mbm file");
414	return res;
415	}
416
417	/* Note: this file is special, because it does not have a complete header! */
418	int psiconv_write_clipart_file(const psiconv_config config,
419	psiconv_buffer buf,int lev,psiconv_clipart_f value)
420	{
421	int res,i;
422	psiconv_jumptable_section jumptable;
423	psiconv_u32 *entry,id;
424	psiconv_clipart_section section;
425	psiconv_buffer sec_buf;
426
427	psiconv_progress(config,lev,0,"Writing clipart file");
428	if (!value) {
429	psiconv_error(config,lev,0,"Null Clipart file");
430	res = -PSICONV_E_GENERATE;
431	goto ERROR1;
432	}
433
434	if (!(jumptable = psiconv_list_new(sizeof(*entry)))) {
435	res = -PSICONV_E_NOMEM;
436	goto ERROR1;
437	}
438
439	if (!(sec_buf = psiconv_buffer_new())) {
440	res = -PSICONV_E_NOMEM;
441	goto ERROR2;
442	}
443
444	if ((res = psiconv_write_u32(config,buf,lev+1,PSICONV_ID_CLIPART)))
445	goto ERROR3;
446
447	for (i = 0; i < psiconv_list_length(value->sections); i++) {
448	if (!(section = psiconv_list_get(value->sections,i))) {
449	psiconv_error(config,lev,0,"Massive memory corruption");
450	res = -PSICONV_E_NOMEM;
451	goto ERROR3;
452	}
453	id = psiconv_buffer_unique_id();
454	psiconv_list_add(jumptable,&id);
455	if ((res = psiconv_buffer_add_target(sec_buf,id)))
456	goto ERROR3;
457	if ((res = psiconv_write_clipart_section(config,sec_buf, lev+1,section)))
458	goto ERROR3;
459	}
460
461	if ((res = psiconv_write_jumptable_section(config,buf,lev+1,jumptable)))
462	goto ERROR3;
463
464	if ((res = psiconv_buffer_concat(buf,sec_buf)))
465	goto ERROR3;
466
467
468	ERROR3:
469	psiconv_buffer_free(sec_buf);
470	ERROR2:
471	psiconv_list_free(jumptable);
472	ERROR1:
473	if (res)
474	psiconv_error(config,lev,0,"Writing of clipart file failed");
475	else
476	psiconv_progress(config,lev,0,"End of clipart file");
477	return res;
478	}
frodo@frodo.looijaard.name	ViewVC Help
Powered by ViewVC 1.1.26