/[public]/psiconv/trunk/lib/psiconv/parse_sheet.c

Diff of /psiconv/trunk/lib/psiconv/parse_sheet.c

Parent Directory | Revision Log | View Patch Patch

Revision 110		Revision 168
…		…
23	#include <stdlib.h>	23	#include <stdlib.h>
24		24
25	#include "parse_routines.h"	25	#include "parse_routines.h"
26	#include "error.h"	26	#include "error.h"
27		27
28	int psiconv_parse_sheet_status_section(const psiconv_buffer buf, int lev,	28	#ifdef DMALLOC
		29	#include <dmalloc.h>
		30	#endif
		31
		32	static psiconv_sheet_cell_layout psiconv_basic_cell_layout(void)
		33	{
		34	psiconv_sheet_cell_layout result;
		35	if (!(result = malloc(sizeof(*result))))
		36	goto ERROR1;
		37	if (!(result->character = psiconv_basic_character_layout()))
		38	goto ERROR2;
		39	if (!(result->paragraph = psiconv_basic_paragraph_layout()))
		40	goto ERROR3;
		41	if (!(result->numberformat = malloc(sizeof(*result->numberformat))))
		42	goto ERROR4;
		43	result->numberformat->code = psiconv_numberformat_general;
		44	result->numberformat->decimal = 2;
		45	return result;
		46	ERROR4:
		47	psiconv_free_paragraph_layout(result->paragraph);
		48	ERROR3:
		49	psiconv_free_character_layout(result->character);
		50	ERROR2:
		51	free(result);
		52	ERROR1:
		53	return NULL;
		54	}
		55
		56	static psiconv_sheet_cell_layout psiconv_clone_cell_layout
		57	(psiconv_sheet_cell_layout original)
		58	{
		59	psiconv_sheet_cell_layout result;
		60	if (!(result = malloc(sizeof(*result))))
		61	goto ERROR1;
		62	if (!(result->character =
		63	psiconv_clone_character_layout(original->character)))
		64	goto ERROR2;
		65	if (!(result->paragraph =
		66	psiconv_clone_paragraph_layout(original->paragraph)))
		67	goto ERROR3;
		68	if (!(result->numberformat = malloc(sizeof(*result->numberformat))))
		69	goto ERROR4;
		70	result->numberformat->code = original->numberformat->code;
		71	result->numberformat->decimal = original->numberformat->decimal;
		72	return result;
		73	ERROR4:
		74	psiconv_free_paragraph_layout(result->paragraph);
		75	ERROR3:
		76	psiconv_free_character_layout(result->character);
		77	ERROR2:
		78	free(result);
		79	ERROR1:
		80	return NULL;
		81	}
		82
		83	static psiconv_sheet_cell_reference_t
		84	psiconv_read_var_cellref (const psiconv_config config,
		85	const psiconv_buffer buf, int lev,
		86	psiconv_u32 off, int *length,
		87	int *status)
		88	{
		89	int len=0;
		90	int res;
		91	psiconv_sheet_cell_reference_t result;
		92	psiconv_u32 temp;
		93
		94	psiconv_progress(config,lev+1,off+len,"Going to read a sheet cell reference");
		95	psiconv_progress(config,lev+2,off+len,
		96	"Going to read the initial byte (%02x expected)",0x00);
		97	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		98	if (res)
		99	goto ERROR1;
		100	if (temp != 0x00) {
		101	psiconv_warn(config,lev+2,off+len,
		102	"Sheet cell reference initial byte unknown value (ignored)");
		103	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
		104	}
		105	len ++;
		106
		107	temp = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		108	if (res)
		109	goto ERROR1;
		110	if (temp & 0xffff0000) {
		111	psiconv_warn(config,lev+2,off+len,
		112	"Sheet cell row reference to unknown row (reset)");
		113	}
		114	result.row.offset = temp;
		115	result.row.absolute = psiconv_bool_true;
		116	len += 4;
		117
		118	temp = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		119	if (res)
		120	goto ERROR1;
		121	if (temp & 0xffff0000) {
		122	psiconv_warn(config,lev+2,off+len,
		123	"Sheet cell column reference to unknown row (reset)");
		124	}
		125	result.column.offset = temp;
		126	result.column.absolute = psiconv_bool_true;
		127	len += 4;
		128
		129	if (length)
		130	*length = len;
		131
		132	psiconv_progress(config,lev,off+len-1,
		133	"End of sheet column reference (total length: %08x)", len);
		134	return result;
		135	ERROR1:
		136	psiconv_warn(config,lev+1,off,"Reading of Sheet Column Reference failed");
		137	if (length)
		138	*length = 0;
		139	if (status)
		140	*status = res?res:-PSICONV_E_NOMEM;
		141	return result;
		142	}
		143
		144	static psiconv_sheet_cell_block_t
		145	psiconv_read_var_cellblock (const psiconv_config config,
		146	const psiconv_buffer buf, int lev,
		147	psiconv_u32 off, int *length,
		148	int *status)
		149	{
		150	int len=0;
		151	int res;
		152	psiconv_sheet_cell_block_t result;
		153	psiconv_u32 temp;
		154
		155	psiconv_progress(config,lev+1,off+len,"Going to read a sheet cell block reference");
		156	psiconv_progress(config,lev+2,off+len,
		157	"Going to read the initial byte (%02x expected)",0x00);
		158	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		159	if (res)
		160	goto ERROR1;
		161	if (temp != 0x00) {
		162	psiconv_warn(config,lev+2,off+len,
		163	"Sheet cell reference initial byte unknown value (ignored)");
		164	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
		165	}
		166	len ++;
		167
		168	temp = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		169	if (res)
		170	goto ERROR1;
		171	if (temp & 0xffff0000) {
		172	psiconv_warn(config,lev+2,off+len,
		173	"Sheet block initial row reference to unknown row (reset)");
		174	}
		175	result.first.row.offset = temp;
		176	result.first.row.absolute = psiconv_bool_true;
		177	len += 4;
		178
		179	temp = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		180	if (res)
		181	goto ERROR1;
		182	if (temp & 0xffff0000) {
		183	psiconv_warn(config,lev+2,off+len,
		184	"Sheet block initial column reference to unknown row (reset)");
		185	}
		186	result.first.column.offset = temp;
		187	result.first.column.absolute = psiconv_bool_true;
		188	len += 4;
		189
		190	temp = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		191	if (res)
		192	goto ERROR1;
		193	if (temp & 0xffff0000) {
		194	psiconv_warn(config,lev+2,off+len,
		195	"Sheet block final row reference to unknown row (reset)");
		196	}
		197	result.last.row.offset = temp;
		198	result.last.row.absolute = psiconv_bool_true;
		199	len += 4;
		200
		201	temp = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		202	if (res)
		203	goto ERROR1;
		204	if (temp & 0xffff0000) {
		205	psiconv_warn(config,lev+2,off+len,
		206	"Sheet block final column reference to unknown row (reset)");
		207	}
		208	result.last.column.offset = temp;
		209	result.last.column.absolute = psiconv_bool_true;
		210	len += 4;
		211
		212	if (length)
		213	*length = len;
		214
		215	psiconv_progress(config,lev,off+len-1,
		216	"End of sheet cell block reference (total length: %08x)",
		217	len);
		218	return result;
		219	ERROR1:
		220	psiconv_warn(config,lev+1,off,"Reading of Sheet Cell Block Reference failed");
		221	if (length)
		222	*length = 0;
		223	if (status)
		224	*status = res?res:-PSICONV_E_NOMEM;
		225	return result;
		226	}
		227
		228	int psiconv_parse_sheet_numberformat(const psiconv_config config,
		229	const psiconv_buffer buf, int lev,
29	psiconv_u32 off, int *length,	230	psiconv_u32 off, int *length,
30	psiconv_sheet_status_section *result)	231	psiconv_sheet_numberformat result)
31	{	232	{
32	int res=0;	233	int res=0;
33	int len=0;	234	int len=0;
34	psiconv_u32 temp;	235	psiconv_u8 temp;
35	int leng;
36		236
37	psiconv_progress(lev+1,off,"Going to read the sheet status section");	237	psiconv_progress(config,lev+1,off,"Going to read a sheet numberformat");
38	if (!(result = malloc(sizeof(*result))))
39	goto ERROR1;
40		238
41	psiconv_progress(lev+2,off+len,	239	psiconv_progress(config,lev+2,off+len,
42	"Going to read the initial byte (%02x expected)",0x02);	240	"Going to read the initial byte (%02x expected)",0x02);
43	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	241	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
44	if (res)	242	if (res)
45	goto ERROR2;	243	goto ERROR1;
46	if (temp != 0x02) {	244	if (temp != 0x02) {
47	psiconv_warn(lev+2,off+len,	245	psiconv_warn(config,lev+2,off+len,
48	"Sheet status section initial byte unknown value (ignored)");	246	"Sheet numberformat initial byte unknown value (ignored)");
49	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);	247	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
50	}	248	}
51	len ++;	249	len ++;
52		250
53	psiconv_progress(lev+2,off+len,	251	psiconv_progress(config,lev+2,off+len, "Going to read the code byte");
54	"Going to read the cursor row");	252	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
55	(*result)->cursor_row = psiconv_read_u32(buf,lev+2,off + len,&res);
56	if (res)	253	if (res)
57	goto ERROR2;	254	goto ERROR1;
58	psiconv_debug(lev+2,off+len,"Cursor row: %08x",	255	psiconv_debug(config,lev+2,off+len,"Code: %02x",temp);
59	(*result)->cursor_row);	256	if (temp == 0x00)
60	len += 0x04;	257	result->code = psiconv_numberformat_general;
		258	else if (temp == 0x02)
		259	result->code = psiconv_numberformat_fixeddecimal;
		260	else if (temp == 0x04)
		261	result->code = psiconv_numberformat_scientific;
		262	else if (temp == 0x06)
		263	result->code = psiconv_numberformat_currency;
		264	else if (temp == 0x08)
		265	result->code = psiconv_numberformat_percent;
		266	else if (temp == 0x0A)
		267	result->code = psiconv_numberformat_triads;
		268	else if (temp == 0x0C)
		269	result->code = psiconv_numberformat_boolean;
		270	else if (temp == 0x0E)
		271	result->code = psiconv_numberformat_text;
		272	else if (temp == 0x10)
		273	result->code = psiconv_numberformat_date_dmm;
		274	else if (temp == 0x12)
		275	result->code = psiconv_numberformat_date_mmd;
		276	else if (temp == 0x14)
		277	result->code = psiconv_numberformat_date_ddmmyy;
		278	else if (temp == 0x16)
		279	result->code = psiconv_numberformat_date_mmddyy;
		280	else if (temp == 0x18)
		281	result->code = psiconv_numberformat_date_yymmdd;
		282	else if (temp == 0x1A)
		283	result->code = psiconv_numberformat_date_dmmm;
		284	else if (temp == 0x1C)
		285	result->code = psiconv_numberformat_date_dmmmyy;
		286	else if (temp == 0x1E)
		287	result->code = psiconv_numberformat_date_ddmmmyy;
		288	else if (temp == 0x20)
		289	result->code = psiconv_numberformat_date_mmm;
		290	else if (temp == 0x22)
		291	result->code = psiconv_numberformat_date_monthname;
		292	else if (temp == 0x24)
		293	result->code = psiconv_numberformat_date_mmmyy;
		294	else if (temp == 0x26)
		295	result->code = psiconv_numberformat_date_monthnameyy;
		296	else if (temp == 0x28)
		297	result->code = psiconv_numberformat_date_monthnamedyyyy;
		298	else if (temp == 0x2A)
		299	result->code = psiconv_numberformat_datetime_ddmmyyyyhhii;
		300	else if (temp == 0x2C)
		301	result->code = psiconv_numberformat_datetime_ddmmyyyyHHii;
		302	else if (temp == 0x2E)
		303	result->code = psiconv_numberformat_datetime_mmddyyyyhhii;
		304	else if (temp == 0x30)
		305	result->code = psiconv_numberformat_datetime_mmddyyyyHHii;
		306	else if (temp == 0x32)
		307	result->code = psiconv_numberformat_datetime_yyyymmddhhii;
		308	else if (temp == 0x34)
		309	result->code = psiconv_numberformat_datetime_yyyymmddHHii;
		310	else if (temp == 0x36)
		311	result->code = psiconv_numberformat_time_hhii;
		312	else if (temp == 0x38)
		313	result->code = psiconv_numberformat_time_hhiiss;
		314	else if (temp == 0x3A)
		315	result->code = psiconv_numberformat_time_HHii;
		316	else if (temp == 0x3C)
		317	result->code = psiconv_numberformat_time_HHiiss;
		318	else {
		319	psiconv_warn(config,lev+2,off+len,"Unknown number format (assumed general)");
		320	result->code = psiconv_numberformat_general;
		321	}
		322	len ++;
61		323
62	psiconv_progress(lev+2,off+len,	324	psiconv_progress(config,lev+2,off+len, "Going to read the number of decimals");
63	"Going to read the cursor column");
64	(*result)->cursor_column = psiconv_read_u32(buf,lev+2,off + len,&res);	325	result->decimal = psiconv_read_u8(config,buf,lev+2,off+len,&res) >> 1;
65	if (res)	326	if (res)
66	goto ERROR2;	327	goto ERROR1;
67	psiconv_debug(lev+2,off+len,"Cursor column: %08x",	328	psiconv_debug(config,lev+2,off+len,"Decimals: %d",result->decimal);
68	(*result)->cursor_column);	329	len ++;
69	len += 0x04;
70
71	psiconv_progress(lev+2,off+len,"Going to read initially display graph");
72	if ((res = psiconv_parse_bool(buf,lev+2,off+len,&leng,
73	&(*result)->show_graph)))
74	goto ERROR2;
75	len += leng;
76
77	psiconv_progress(lev+2,off+len,
78	"Going to read the toolbar status byte");
79	temp = psiconv_read_u8(buf,lev+2,off+len,&res);
80	if (res)
81	goto ERROR2;
82
83	(*result)->show_side_sheet_toolbar = temp&0x01 ? psiconv_bool_true :
84	psiconv_bool_false;
85	psiconv_debug(lev+2,off+len,"Show side sheet toolbar: %02x",
86	(*result)->show_side_sheet_toolbar);
87	(*result)->show_top_sheet_toolbar = temp&0x02 ? psiconv_bool_true :
88	psiconv_bool_false;
89	psiconv_debug(lev+2,off+len,"Show top sheet toolbar: %02x",
90	(*result)->show_top_sheet_toolbar);
91	(*result)->show_side_graph_toolbar = temp&0x04 ? psiconv_bool_true :
92	psiconv_bool_false;
93	psiconv_debug(lev+2,off+len,"Show side graph toolbar: %02x",
94	(*result)->show_side_graph_toolbar);
95	(*result)->show_top_graph_toolbar = temp&0x08 ? psiconv_bool_true :
96	psiconv_bool_false;
97	psiconv_debug(lev+2,off+len,"Show top graph toolbar: %02x",
98	(*result)->show_top_graph_toolbar);
99	if (temp & 0xf0) {
100	psiconv_warn(lev+2,off+len,"Sheet status section toolbar byte "
101	"flags contains unknown flags (ignored)");
102	psiconv_debug(lev+2,off+len,"Unknown flags: %02x",temp & 0xf0);
103	}	330
104	len ++;
105
106	psiconv_progress(lev+2,off+len,
107	"Going to read the scrollbar status byte");
108	temp = psiconv_read_u8(buf,lev+2,off+len,&res);
109	if (res)
110	goto ERROR2;
111	if ((temp & 0x03) == 0x03) {
112	psiconv_warn(lev+2,off+len,"Sheet status section scrollbar byte "
113	"flags contains unknown flags (ignored)");
114	psiconv_debug(lev+2,off+len,"Unknown flag: %02x",temp & 0x03);
115	}
116	(*result)->show_horizontal_scrollbar = (temp&0x03) == 1? psiconv_triple_off :
117	(temp&0x03) == 2? psiconv_triple_auto:
118	psiconv_triple_on;
119	psiconv_debug(lev+2,off+len,"Show horizontal scrollbar: %02x",
120	(*result)->show_horizontal_scrollbar);
121	if ((temp & 0x0c) == 0x0c) {
122	psiconv_warn(lev+2,off+len,"Sheet status section scrollbar byte "
123	"flags contains unknown flags (ignored)");
124	psiconv_debug(lev+2,off+len,"Unknown flag: %02x",temp & 0x0c);
125	}
126	(*result)->show_vertical_scrollbar = (temp&0x0c) ==0x04? psiconv_triple_off:
127	(temp&0x0c) ==0x08? psiconv_triple_auto:
128	psiconv_triple_on;
129	psiconv_debug(lev+2,off+len,"Show vertical scrollbar: %02x",
130	(*result)->show_vertical_scrollbar);
131	if (temp & 0xf0) {
132	psiconv_warn(lev+2,off+len,"Sheet status section scrollbar byte "
133	"flags contains unknown flags (ignored)");
134	psiconv_debug(lev+2,off+len,"Unknown flags: %02x",temp & 0xf0);
135	}
136	len ++;
137
138	psiconv_progress(lev+2,off+len,
139	"Going to read an unknown byte (%02x expected)",0x00);
140	temp = psiconv_read_u8(buf,lev+2,off+len,&res);
141	if (res)
142	goto ERROR2;
143	if (temp != 0x00) {
144	psiconv_warn(lev+2,off+len,
145	"Sheet status section unknown byte unknown value (ignored)");
146	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
147	}
148	len ++;
149
150	psiconv_progress(lev+2,off+len,"Going to read sheet display size");
151	(*result)->sheet_display_size = psiconv_read_u32(buf,lev+2,off + len,&res);
152	if (res)
153	goto ERROR2;
154	psiconv_debug(lev+2,off+len,"Sheet display size: %08x",
155	(*result)->sheet_display_size);
156	len += 0x04;
157
158	psiconv_progress(lev+2,off+len,"Going to read graph display size");
159	(*result)->graph_display_size = psiconv_read_u32(buf,lev+2,off + len,&res);
160	if (res)
161	goto ERROR2;
162	psiconv_debug(lev+2,off+len,"Graph display size: %08x",
163	(*result)->graph_display_size);
164	len += 0x04;
165
166	if (length)	331	if (length)
167	*length = len;	332	*length = len;
168		333
169	psiconv_progress(lev,off+len-1,	334	psiconv_progress(config,lev,off+len-1,
170	"End of sheet status section (total length: %08x)", len);	335	"End of sheet number format (total length: %08x)", len);
171	return 0;	336	return 0;
172		337
173	ERROR2:	338	ERROR1:
174	free (*result);
175	ERROR1:
176	psiconv_warn(lev+1,off,"Reading of Sheet Status Section failed");	339	psiconv_warn(config,lev+1,off,"Reading of Sheet Number Format failed");
177	if (length)	340	if (length)
178	*length = 0;	341	*length = 0;
179	if (!res)	342	if (!res)
180	return -PSICONV_E_NOMEM;	343	return -PSICONV_E_NOMEM;
181	else	344	else
182	return res;	345	return res;
183	}	346	}
184		347
185	int psiconv_parse_sheet_workbook_section(const psiconv_buffer buf, int lev,	348	int psiconv_parse_sheet_status_section(const psiconv_config config,
		349	const psiconv_buffer buf, int lev,
186	psiconv_u32 off, int *length,	350	psiconv_u32 off, int *length,
187	psiconv_sheet_workbook_section *result)	351	psiconv_sheet_status_section *result)
188	{	352	{
189	int res=0;	353	int res=0;
190	psiconv_u32 temp,formulas_off,worksheets_off;
191	int len=0;	354	int len=0;
		355	psiconv_u32 temp;
		356	int leng;
192		357
193	psiconv_progress(lev+1,off,"Going to read the sheet workbook section");	358	psiconv_progress(config,lev+1,off,"Going to read the sheet status section");
194	if (!(result = malloc(sizeof(*result))))	359	if (!(result = malloc(sizeof(*result))))
195	goto ERROR1;	360	goto ERROR1;
196		361
197	psiconv_progress(lev+2,off+len,	362	psiconv_progress(config,lev+2,off+len,
198	"Going to read the initial byte (%02x expected)",0x04);	363	"Going to read the initial byte (%02x expected)",0x02);
199	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	364	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
200	if (res)	365	if (res)
201	goto ERROR2;	366	goto ERROR2;
202	if (temp != 0x04) {	367	if (temp != 0x02) {
203	psiconv_warn(lev+2,off+len,	368	psiconv_warn(config,lev+2,off+len,
204	"Sheet workbook section initial byte unknown value (ignored)");	369	"Sheet status section initial byte unknown value (ignored)");
205	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);	370	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
206	}	371	}
207	len ++;	372	len ++;
208		373
209	psiconv_progress(lev+2,off+len,	374	psiconv_progress(config,lev+2,off+len,
210	"Going to read the offset of the 1st ??? Section");	375	"Going to read the cursor row");
		376	(*result)->cursor_row = psiconv_read_u32(config,buf,lev+2,off + len,&res);
		377	if (res)
		378	goto ERROR2;
		379	psiconv_debug(config,lev+2,off+len,"Cursor row: %08x",
		380	(*result)->cursor_row);
		381	len += 0x04;
		382
		383	psiconv_progress(config,lev+2,off+len,
		384	"Going to read the cursor column");
		385	(*result)->cursor_column = psiconv_read_u32(config,buf,lev+2,off + len,&res);
		386	if (res)
		387	goto ERROR2;
		388	psiconv_debug(config,lev+2,off+len,"Cursor column: %08x",
		389	(*result)->cursor_column);
		390	len += 0x04;
		391
		392	psiconv_progress(config,lev+2,off+len,"Going to read initially display graph");
		393	if ((res = psiconv_parse_bool(config,buf,lev+2,off+len,&leng,
		394	&(*result)->show_graph)))
		395	goto ERROR2;
		396	len += leng;
		397
		398	psiconv_progress(config,lev+2,off+len,
		399	"Going to read the toolbar status byte");
211	temp = psiconv_read_u32(buf,lev+2,off+len,&res);	400	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
212	if (res)	401	if (res)
213	goto ERROR2;	402	goto ERROR2;
214	psiconv_debug(lev+2,off+len,"Offset: %04x",temp);	403
		404	(*result)->show_side_sheet_toolbar = temp&0x01 ? psiconv_bool_true :
		405	psiconv_bool_false;
		406	psiconv_debug(config,lev+2,off+len,"Show side sheet toolbar: %02x",
		407	(*result)->show_side_sheet_toolbar);
		408	(*result)->show_top_sheet_toolbar = temp&0x02 ? psiconv_bool_true :
		409	psiconv_bool_false;
		410	psiconv_debug(config,lev+2,off+len,"Show top sheet toolbar: %02x",
		411	(*result)->show_top_sheet_toolbar);
		412	(*result)->show_side_graph_toolbar = temp&0x04 ? psiconv_bool_true :
		413	psiconv_bool_false;
		414	psiconv_debug(config,lev+2,off+len,"Show side graph toolbar: %02x",
		415	(*result)->show_side_graph_toolbar);
		416	(*result)->show_top_graph_toolbar = temp&0x08 ? psiconv_bool_true :
		417	psiconv_bool_false;
		418	psiconv_debug(config,lev+2,off+len,"Show top graph toolbar: %02x",
		419	(*result)->show_top_graph_toolbar);
		420	if (temp & 0xf0) {
		421	psiconv_warn(config,lev+2,off+len,"Sheet status section toolbar byte "
		422	"flags contains unknown flags (ignored)");
		423	psiconv_debug(config,lev+2,off+len,"Unknown flags: %02x",temp & 0xf0);
		424	}
215	len += 4;	425	len ++;
216		426
217	psiconv_progress(lev+2,off+len,	427	psiconv_progress(config,lev+2,off+len,
218	"Going to read the offset of the Formulas List");	428	"Going to read the scrollbar status byte");
219	formulas_off = psiconv_read_u32(buf,lev+2,off+len,&res);
220	if (res)
221	goto ERROR2;
222	psiconv_debug(lev+2,off+len,"Offset: %04x",formulas_off);
223	len += 4;
224
225	psiconv_progress(lev+2,off+len,
226	"Going to read the offset of the Worksheets Section");
227	worksheets_off = psiconv_read_u32(buf,lev+2,off+len,&res);
228	if (res)
229	goto ERROR2;
230	psiconv_debug(lev+2,off+len,"Offset: %04x",temp);
231	len += 4;
232
233	psiconv_progress(lev+2,off+len,
234	"Going to read the offset of the 4th ??? Section");
235	temp = psiconv_read_u32(buf,lev+2,off+len,&res);	429	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
236	if (res)	430	if (res)
237	goto ERROR2;	431	goto ERROR2;
		432	if ((temp & 0x03) == 0x03) {
		433	psiconv_warn(config,lev+2,off+len,"Sheet status section scrollbar byte "
		434	"flags contains unknown flags (ignored)");
		435	psiconv_debug(config,lev+2,off+len,"Unknown flag: %02x",temp & 0x03);
		436	}
		437	(*result)->show_horizontal_scrollbar = (temp&0x03) == 1? psiconv_triple_off :
		438	(temp&0x03) == 2? psiconv_triple_auto:
		439	psiconv_triple_on;
		440	psiconv_debug(config,lev+2,off+len,"Show horizontal scrollbar: %02x",
		441	(*result)->show_horizontal_scrollbar);
		442	if ((temp & 0x0c) == 0x0c) {
		443	psiconv_warn(config,lev+2,off+len,"Sheet status section scrollbar byte "
		444	"flags contains unknown flags (ignored)");
		445	psiconv_debug(config,lev+2,off+len,"Unknown flag: %02x",temp & 0x0c);
		446	}
		447	(*result)->show_vertical_scrollbar = (temp&0x0c) ==0x04? psiconv_triple_off:
		448	(temp&0x0c) ==0x08? psiconv_triple_auto:
		449	psiconv_triple_on;
		450	psiconv_debug(config,lev+2,off+len,"Show vertical scrollbar: %02x",
		451	(*result)->show_vertical_scrollbar);
		452	if (temp & 0xf0) {
		453	psiconv_warn(config,lev+2,off+len,"Sheet status section scrollbar byte "
		454	"flags contains unknown flags (ignored)");
		455	psiconv_debug(config,lev+2,off+len,"Unknown flags: %02x",temp & 0xf0);
		456	}
		457	len ++;
		458
		459	psiconv_progress(config,lev+2,off+len,
		460	"Going to read an unknown byte (%02x expected)",0x00);
		461	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		462	if (res)
		463	goto ERROR2;
		464	if (temp != 0x00) {
		465	psiconv_warn(config,lev+2,off+len,
		466	"Sheet status section unknown byte unknown value (ignored)");
238	psiconv_debug(lev+2,off+len,"Offset: %04x",temp);	467	psiconv_debug(config,lev+2,off+len,"Unknown byte: %02x",temp);
		468	}
		469	len ++;
		470
		471	psiconv_progress(config,lev+2,off+len,"Going to read sheet display size");
		472	(*result)->sheet_display_size = psiconv_read_u32(config,buf,lev+2,off + len,&res);
		473	if (res)
		474	goto ERROR2;
		475	psiconv_debug(config,lev+2,off+len,"Sheet display size: %08x",
		476	(*result)->sheet_display_size);
239	len += 4;	477	len += 0x04;
240		478
241	psiconv_progress(lev+2,off+len,"Going to read the formulas list");	479	psiconv_progress(config,lev+2,off+len,"Going to read graph display size");
242	if ((res = psiconv_parse_sheet_formula_table(buf,lev+2,formulas_off,NULL,	480	(*result)->graph_display_size = psiconv_read_u32(config,buf,lev+2,off + len,&res);
243	&(*result)->formulas)))	481	if (res)
244	goto ERROR2;	482	goto ERROR2;
245		483	psiconv_debug(config,lev+2,off+len,"Graph display size: %08x",
246	psiconv_progress(lev+2,off+len,"Going to read the worksheets");	484	(*result)->graph_display_size);
247	if ((res = psiconv_parse_sheet_worksheet_section(buf,lev+2,worksheets_off,	485	len += 0x04;
248	NULL,&(*result)->worksheet)))
249	goto ERROR2;
250		486
251
252	if (length)	487	if (length)
253	*length = len;	488	*length = len;
254		489
255	psiconv_progress(lev,off+len-1,	490	psiconv_progress(config,lev,off+len-1,
256	"End of sheet workbook section (total length: %08x)", len);	491	"End of sheet status section (total length: %08x)", len);
257	return 0;	492	return 0;
258		493
259	ERROR2:	494	ERROR2:
260	free (*result);	495	free (*result);
261	ERROR1:	496	ERROR1:
262	psiconv_warn(lev+1,off,"Reading of Sheet Workbook Section failed");	497	psiconv_warn(config,lev+1,off,"Reading of Sheet Status Section failed");
263	if (length)	498	if (length)
264	*length = 0;	499	*length = 0;
265	if (!res)	500	if (!res)
266	return -PSICONV_E_NOMEM;	501	return -PSICONV_E_NOMEM;
267	else	502	else
268	return res;	503	return res;
269	}	504	}
270		505
271	int psiconv_parse_sheet_formula_table(const psiconv_buffer buf, int lev,	506	int psiconv_parse_sheet_workbook_section(const psiconv_config config,
		507	const psiconv_buffer buf, int lev,
		508	psiconv_u32 off, int *length,
		509	psiconv_sheet_workbook_section *result)
		510	{
		511	int res=0,with_name;
		512	psiconv_u32 temp,formulas_off,worksheets_off,info_off,var_off,name_off=0;
		513	int len=0;
		514
		515	psiconv_progress(config,lev+1,off,"Going to read the sheet workbook section");
		516	if (!(result = malloc(sizeof(*result))))
		517	goto ERROR1;
		518
		519	psiconv_progress(config,lev+2,off+len,
		520	"Going to read the initial byte (%02x or %02x expected)",
		521	0x02,0x04);
		522	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		523	if (res)
		524	goto ERROR2;
		525	if ((temp != 0x04) && temp !=0x02) {
		526	psiconv_warn(config,lev+2,off+len,
		527	"Sheet workbook section initial byte unknown value (ignored)");
		528	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
		529	}
		530	with_name = temp ==0x04;
		531	len ++;
		532
		533	psiconv_progress(config,lev+2,off+len,
		534	"Going to read the offset of the sheet info Section");
		535	info_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		536	if (res)
		537	goto ERROR2;
		538	psiconv_debug(config,lev+2,off+len,"Offset: %04x",info_off);
		539	len += 4;
		540
		541	psiconv_progress(config,lev+2,off+len,
		542	"Going to read the offset of the Formulas List");
		543	formulas_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		544	if (res)
		545	goto ERROR2;
		546	psiconv_debug(config,lev+2,off+len,"Offset: %04x",formulas_off);
		547	len += 4;
		548
		549	psiconv_progress(config,lev+2,off+len,
		550	"Going to read the offset of the Worksheet List");
		551	worksheets_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		552	if (res)
		553	goto ERROR2;
		554	psiconv_debug(config,lev+2,off+len,"Offset: %04x",worksheets_off);
		555	len += 4;
		556
		557	psiconv_progress(config,lev+2,off+len,
		558	"Going to read the offset of the Variable List");
		559	var_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		560	if (res)
		561	goto ERROR2;
		562	psiconv_debug(config,lev+2,off+len,"Offset: %04x",var_off);
		563	len += 4;
		564
		565	if (with_name) {
		566	psiconv_progress(config,lev+2,off+len,
		567	"Going to read the offset of the Name Section");
		568	name_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		569	if (res)
		570	goto ERROR2;
		571	psiconv_debug(config,lev+2,off+len,"Offset: %04x",name_off);
		572	len += 4;
		573	}
		574
		575
		576	psiconv_progress(config,lev+2,off+len,"Going to read the info section");
		577	if ((res = psiconv_parse_sheet_info_section(config,buf,lev+2,info_off,NULL,
		578	&(*result)->info)))
		579	goto ERROR2;
		580
		581	psiconv_progress(config,lev+2,off+len,"Going to read the variables list");
		582	if ((res = psiconv_parse_sheet_variable_list(config,buf,lev+2,var_off,NULL,
		583	&(*result)->variables)))
		584	goto ERROR3;
		585
		586	psiconv_progress(config,lev+2,off+len,"Going to read the formulas list");
		587	if ((res = psiconv_parse_sheet_formula_list(config,buf,lev+2,formulas_off,NULL,
		588	&(*result)->formulas)))
		589	goto ERROR4;
		590
		591	psiconv_progress(config,lev+2,off+len,"Going to read the worksheet list");
		592	if ((res = psiconv_parse_sheet_worksheet_list(config,buf,lev+2,worksheets_off,
		593	NULL,&(*result)->worksheets)))
		594	goto ERROR5;
		595
		596	if (with_name) {
		597	psiconv_progress(config,lev+2,off+len,"Going to read the name section");
		598	if ((res = psiconv_parse_sheet_name_section(config,buf,lev+2,name_off,NULL,
		599	&(*result)->name)))
		600	goto ERROR6;
		601	} else
		602	(*result)->name = NULL;
		603
		604	if (length)
		605	*length = len;
		606
		607	psiconv_progress(config,lev,off+len-1,
		608	"End of sheet workbook section (total length: %08x)", len);
		609	return 0;
		610
		611	ERROR6:
		612	psiconv_free_sheet_worksheet_list((*result)->worksheets);
		613	ERROR5:
		614	psiconv_free_formula_list((*result)->formulas);
		615	ERROR4:
		616	psiconv_free_sheet_variable_list((*result)->variables);
		617	ERROR3:
		618	psiconv_free_sheet_info_section((*result)->info);
		619	ERROR2:
		620	free (*result);
		621	ERROR1:
		622	psiconv_warn(config,lev+1,off,"Reading of Sheet Workbook Section failed");
		623	if (length)
		624	*length = 0;
		625	if (!res)
		626	return -PSICONV_E_NOMEM;
		627	else
		628	return res;
		629	}
		630
		631	int psiconv_parse_sheet_name_section(const psiconv_config config,
		632	const psiconv_buffer buf, int lev,
272	psiconv_u32 off, int *length,	633	psiconv_u32 off, int *length,
		634	psiconv_sheet_name_section *result)
		635	{
		636	int res=0;
		637	psiconv_u32 temp;
		638	int len=0,leng;
		639
		640	psiconv_progress(config,lev+1,off,"Going to read the sheet name section");
		641	if (!(result = malloc(sizeof(*result))))
		642	goto ERROR1;
		643
		644	psiconv_progress(config,lev+2,off+len,
		645	"Going to read the initial byte (%02x expected)",0x02);
		646	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		647	if (res)
		648	goto ERROR2;
		649	if (temp != 0x02) {
		650	psiconv_warn(config,lev+2,off+len,
		651	"Sheet name section initial byte unknown value (ignored)");
		652	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
		653	}
		654	len ++;
		655
		656	psiconv_progress(config,lev+2,off+len, "Going to read the sheet name");
		657	(*result)->name = psiconv_read_string(config,buf,lev+2,off+len,&leng,&res);
		658	if (res)
		659	goto ERROR2;
		660	len += leng;
		661
		662	if (length)
		663	*length = len;
		664
		665	psiconv_progress(config,lev,off+len-1,
		666	"End of sheet name section (total length: %08x)", len);
		667	return 0;
		668
		669	ERROR2:
		670	free(*result);
		671	ERROR1:
		672	psiconv_warn(config,lev+1,off,"Reading of Sheet Name Section failed");
		673	if (length)
		674	*length = 0;
		675	if (!res)
		676	return -PSICONV_E_NOMEM;
		677	else
		678	return res;
		679	}
		680
		681	int psiconv_parse_sheet_info_section(const psiconv_config config,
		682	const psiconv_buffer buf, int lev,
		683	psiconv_u32 off, int *length,
		684	psiconv_sheet_info_section *result)
		685	{
		686	int res=0;
		687	psiconv_u32 temp;
		688	int len=0,leng;
		689
		690	psiconv_progress(config,lev+1,off,"Going to read the sheet info section");
		691	if (!(result = malloc(sizeof(*result))))
		692	goto ERROR1;
		693
		694	psiconv_progress(config,lev+2,off+len,
		695	"Going to read the initial byte (%02x expected)",0x02);
		696	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		697	if (res)
		698	goto ERROR2;
		699	if (temp != 0x02) {
		700	psiconv_warn(config,lev+2,off+len,
		701	"Sheet info section initial byte unknown value (ignored)");
		702	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
		703	}
		704	len ++;
		705
		706	psiconv_progress(config,lev+2,off+len, "Going to read an unknown Xint");
		707	temp = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
		708	if (res)
		709	goto ERROR2;
		710	psiconv_debug(config,lev+2,off+len,"Value: %d\n",temp);
		711	len += leng;
		712
		713	psiconv_progress(config,lev+2,off+len, "Going to read the flags byte");
		714	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		715	if (res)
		716	goto ERROR2;
		717	(*result)->auto_recalc = temp & 0x01 ? psiconv_bool_true:psiconv_bool_false;
		718	psiconv_debug(config,lev+2,off+len,"Auto recalculation: %02x",
		719	(*result)->auto_recalc);
		720	if ((temp & 0xfe) != 0x02) {
		721	psiconv_warn(config,lev+2,off+len,"Sheet Info Section flags byte "
		722	"contains unknown flags (ignored)");
		723	psiconv_debug(config,lev+2,off+len,"Unknown flags: %02x",temp &0xfe);
		724	}
		725
		726	len ++;
		727
		728
		729	if (length)
		730	*length = len;
		731
		732	psiconv_progress(config,lev,off+len-1,
		733	"End of sheet info section (total length: %08x)", len);
		734	return 0;
		735
		736	ERROR2:
		737	free(*result);
		738	ERROR1:
		739	psiconv_warn(config,lev+1,off,"Reading of Sheet Name Section failed");
		740	if (length)
		741	*length = 0;
		742	if (!res)
		743	return -PSICONV_E_NOMEM;
		744	else
		745	return res;
		746	}
		747
		748	int psiconv_parse_sheet_formula_list(const psiconv_config config,
		749	const psiconv_buffer buf, int lev,
		750	psiconv_u32 off, int *length,
273	psiconv_formula_list *result)	751	psiconv_formula_list *result)
274	{	752	{
275	int res=0;	753	int res=0;
276	int len=0;	754	int len=0;
277	psiconv_u32 temp;	755	psiconv_u32 temp;
278	psiconv_formula formula;	756	psiconv_formula formula;
279	psiconv_u32 listlen,i;	757	psiconv_u32 listlen,i;
280	int leng;	758	int leng;
281		759
282	psiconv_progress(lev+1,off,"Going to read the sheet formula table");	760	psiconv_progress(config,lev+1,off,"Going to read the sheet formula list");
283	if (!(*result = psiconv_list_new(sizeof(struct psiconv_formula_s))))	761	if (!(*result = psiconv_list_new(sizeof(struct psiconv_formula_s))))
284	goto ERROR1;	762	goto ERROR1;
285		763
286	psiconv_progress(lev+2,off+len,	764	psiconv_progress(config,lev+2,off+len,
287	"Going to read the initial byte (%02x expected)",0x02);	765	"Going to read the initial byte (%02x expected)",0x02);
288	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	766	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
289	if (res)	767	if (res)
290	goto ERROR2;	768	goto ERROR2;
291	if (temp != 0x02) {	769	if (temp != 0x02) {
292	psiconv_warn(lev+2,off+len,	770	psiconv_warn(config,lev+2,off+len,
293	"Sheet formula table initial byte unknown value (ignored)");	771	"Sheet formula list initial byte unknown value (ignored)");
294	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);	772	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
295	}	773	}
296	len ++;	774	len ++;
297		775
298	psiconv_progress(lev+2,off+len,	776	psiconv_progress(config,lev+2,off+len,
299	"Going to read the number of formulas");	777	"Going to read the number of formulas");
300	listlen = psiconv_read_X(buf,lev+2,off+len,&leng,&res);	778	listlen = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
301	if (res)	779	if (res)
302	goto ERROR2;	780	goto ERROR2;
303	psiconv_debug(lev+2,off+len,"Number of formulas: %d",listlen);	781	psiconv_debug(config,lev+2,off+len,"Number of formulas: %d",listlen);
304	len += leng;	782	len += leng;
305		783
306	psiconv_progress(lev+2,off+len,"Going to read all formulas");	784	psiconv_progress(config,lev+2,off+len,"Going to read all formulas");
307	for (i = 0; i < listlen; i++) {	785	for (i = 0; i < listlen; i++) {
308	psiconv_progress(lev+3,off+len,"Going to read formula %d",i);	786	psiconv_progress(config,lev+3,off+len,"Going to read formula %d",i);
309	if ((res = psiconv_parse_formula(buf,lev+3,off+len,&leng,&formula)))	787	if ((res = psiconv_parse_formula(config,buf,lev+3,off+len,&leng,&formula)))
310	goto ERROR2;	788	goto ERROR2;
311	if ((res = psiconv_list_add(*result,formula)))	789	if ((res = psiconv_list_add(*result,formula)))
312	goto ERROR3;	790	goto ERROR3;
		791	free(formula);
313	len += leng;	792	len += leng;
314	}	793	}
315		794
316	if (length)	795	if (length)
317	*length = len;	796	*length = len;
318		797
319	psiconv_progress(lev,off+len-1,	798	psiconv_progress(config,lev,off+len-1,
320	"End of sheet formula table (total length: %08x)", len);	799	"End of sheet formula list (total length: %08x)", len);
321	return 0;	800	return 0;
322		801
323	ERROR3:	802	ERROR3:
324	psiconv_free_formula(formula);	803	psiconv_free_formula(formula);
325	ERROR2:	804	ERROR2:
326	psiconv_list_free(*result);	805	psiconv_list_free(*result);
327	ERROR1:	806	ERROR1:
328	psiconv_warn(lev+1,off,"Reading of Sheet Formula Table failed");	807	psiconv_warn(config,lev+1,off,"Reading of Sheet Formula list failed");
329	if (length)	808	if (length)
330	*length = 0;	809	*length = 0;
331	if (!res)	810	if (!res)
332	return -PSICONV_E_NOMEM;	811	return -PSICONV_E_NOMEM;
333	else	812	else
334	return res;	813	return res;
335	}	814	}
336		815
337	int psiconv_parse_sheet_cell(const psiconv_buffer buf, int lev,	816	int psiconv_parse_sheet_cell(const psiconv_config config,
		817	const psiconv_buffer buf, int lev,
338	psiconv_u32 off, int *length,	818	psiconv_u32 off, int *length,
339	psiconv_sheet_cell *result)	819	psiconv_sheet_cell *result,
		820	const psiconv_sheet_cell_layout default_layout,
		821	const psiconv_sheet_line_list row_default_layouts,
		822	const psiconv_sheet_line_list col_default_layouts)
340	{	823	{
341	int res=0;	824	int res=0;
342	int len=0;	825	int len=0;
343	psiconv_u32 temp;	826	psiconv_u32 temp;
344	psiconv_bool_t has_layout;	827	psiconv_bool_t has_layout;
345	int leng;	828	int leng;
346		829
347	psiconv_progress(lev+1,off,"Going to read a sheet cell structure");	830	psiconv_progress(config,lev+1,off,"Going to read a sheet cell structure");
348	if (!(result = malloc(sizeof(*result))))	831	if (!(result = malloc(sizeof(*result))))
349	goto ERROR1;	832	goto ERROR1;
350		833
		834	(*result)->layout = NULL;
		835	(*result)->type = psiconv_cell_blank;
		836
351	psiconv_progress(lev+2,off+len,"Going to read the cell position");	837	psiconv_progress(config,lev+2,off+len,"Going to read the cell position");
352	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	838	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
353	if (res)	839	if (res)
354	goto ERROR2;	840	goto ERROR2;
355	len ++;	841	len ++;
356	temp += psiconv_read_u8(buf,lev+2,off+len,&res) << 8;	842	temp += psiconv_read_u8(config,buf,lev+2,off+len,&res) << 8;
357	if (res)	843	if (res)
358	goto ERROR2;	844	goto ERROR2;
359	len ++;	845	len ++;
360	temp += psiconv_read_u8(buf,lev+2,off+len,&res) << 16;	846	temp += psiconv_read_u8(config,buf,lev+2,off+len,&res) << 16;
361	if (res)	847	if (res)
362	goto ERROR2;	848	goto ERROR2;
363	len ++;	849	len ++;
364	(*result)->column = (temp >> 2) & 0xFF;	850	(*result)->column = (temp >> 2) & 0xFF;
365	(*result)->row = (temp >> 10) & 0x3FFF;	851	(*result)->row = (temp >> 10) & 0x3FFF;
366	psiconv_debug(lev+2,off+len,"Cell position is col:%02x row:%04x",	852	psiconv_debug(config,lev+2,off+len,"Cell position is col:%02x row:%04x",
367	(result)->column,(result)->row);	853	(result)->column,(result)->row);
		854	if (temp & 0x03) {
		855	psiconv_warn(config,lev+2,off+len,"Unknown flags in cell position (ignored)");
		856	psiconv_debug(config,lev+2,off+len,"Flags: %02x",temp & 0x03);
		857	}
368		858
369	psiconv_progress(lev+2,off+len,"Going to read the cell type");	859	psiconv_progress(config,lev+2,off+len,"Going to read the cell type");
370	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	860	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
371	if (res)	861	if (res)
372	goto ERROR2;	862	goto ERROR2;
373	len ++;	863	len ++;
374	(*result)->type = (temp >> 5) & 0x07;	864	(*result)->type = (temp >> 5) & 0x07;
375	(*result)->calculated = (temp & 0x08)?psiconv_bool_true:psiconv_bool_false;	865	(*result)->calculated = (temp & 0x08)?psiconv_bool_true:psiconv_bool_false;
376	has_layout = (temp & 0x10)?psiconv_bool_true:psiconv_bool_false;	866	has_layout = (temp & 0x10)?psiconv_bool_true:psiconv_bool_false;
377		867
378	psiconv_progress(lev+2,off+len,"Going to read the cell value");	868	psiconv_progress(config,lev+2,off+len,"Going to read the cell value");
379	if ((*result)->type == psiconv_cell_blank) {	869	if ((*result)->type == psiconv_cell_blank) {
380	psiconv_debug(lev+2,off+len,"Cell type is blank: no value given.");	870	psiconv_debug(config,lev+2,off+len,"Cell type is blank: no value given.");
381	} else if ((*result)->type == psiconv_cell_int) {	871	} else if ((*result)->type == psiconv_cell_int) {
382	psiconv_progress(lev+2,off+len,"Going to read an integer");	872	psiconv_progress(config,lev+2,off+len,"Going to read an integer");
383	(*result)->data.dat_int = psiconv_read_u32(buf,lev+2,off+len,&res);	873	(*result)->data.dat_int = psiconv_read_u32(config,buf,lev+2,off+len,&res);
384	if (res)	874	if (res)
385	goto ERROR2;	875	goto ERROR2;
386	len += 4;	876	len += 4;
387	psiconv_debug(lev+2,off+len,"Cell contents: %ld",(*result)->data.dat_int);	877	psiconv_debug(config,lev+2,off+len,"Cell contents: %ld",(*result)->data.dat_int);
388		878
389	} else if ((*result)->type == psiconv_cell_bool) {	879	} else if ((*result)->type == psiconv_cell_bool) {
390	psiconv_progress(lev+2,off+len,"Going to read a boolean");	880	psiconv_progress(config,lev+2,off+len,"Going to read a boolean");
391	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	881	if ((res = psiconv_parse_bool(config,buf,lev+2,off+len,&leng,
392	if (res)	882	&(*result)->data.dat_bool)))
393	goto ERROR2;	883	goto ERROR2;
394	len ++;
395	psiconv_debug(lev+2,off+len,"Cell contents: %01x",temp);	884	psiconv_debug(config,lev+2,off+len,"Cell contents: %01x",temp);
396	(*result)->data.dat_bool = temp?psiconv_bool_true:psiconv_bool_false;	885	(*result)->data.dat_bool = temp?psiconv_bool_true:psiconv_bool_false;
397		886	len += leng;
398	} else if ((*result)->type == psiconv_cell_error) {	887	} else if ((*result)->type == psiconv_cell_error) {
399	psiconv_progress(lev+2,off+len,"Going to read the error code");	888	psiconv_progress(config,lev+2,off+len,"Going to read the error code");
400	(*result)->data.dat_error = psiconv_read_u16(buf,lev+2,off+len,&res);
401	if (res)
402	goto ERROR2;
403	len += 2;
404	psiconv_debug(lev+2,off+len,"Cell contents: %04x",
405	(*result)->data.dat_error);
406
407	} else if ((*result)->type == psiconv_cell_float) {
408	psiconv_progress(lev+2,off+len,"Going to read a float");
409	(*result)->data.dat_float =
410	psiconv_read_float(buf,lev+2,off+len,&leng,&res);
411	if (res)
412	goto ERROR2;
413	len += leng;
414	psiconv_debug(lev+2,off+len,"Cell contents: %f",(*result)->data.dat_float);
415
416	} else if ((*result)->type == psiconv_cell_string) {
417	psiconv_progress(lev+2,off+len,"Going to read a string");
418	(*result)->data.dat_string =
419	psiconv_read_short_string(buf,lev+2,off+len,&leng,&res);
420	if (res)
421	goto ERROR2;
422	len += leng;
423	psiconv_debug(lev+2,off+len,"Cell contents: `%s'",
424	(*result)->data.dat_string);
425	} else {
426	psiconv_warn(lev+2,off+len,"Unknown Sheet Cell type: %02x",(*result)->type);
427	}
428
429	if (has_layout) {
430	psiconv_progress(lev+2,off+len,"Going to read the cell layout");
431
432	psiconv_progress(lev+2,off+len,"Going to read the cell layout flags");
433	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	889	temp = psiconv_read_u16(config,buf,lev+2,off+len,&res);
434	if (res)	890	if (res)
435	goto ERROR2;	891	goto ERROR2;
436	len ++;
437
438	if (temp & 0x01) {	892	if (temp == 0)
439	if (!((*result)->paragraph = psiconv_basic_paragraph_layout()))	893	(*result)->data.dat_error = psiconv_sheet_error_none;
440	goto ERROR2;	894	else if (temp == 1)
441	psiconv_progress(lev+3,off+len,"Going to read the paragraph codes");	895	(*result)->data.dat_error = psiconv_sheet_error_null;
442	if ((res = psiconv_parse_paragraph_layout_list(buf,lev+3,off+len,&leng,	896	else if (temp == 2)
443	(*result)->paragraph)))	897	(*result)->data.dat_error = psiconv_sheet_error_divzero;
444	goto ERROR2;	898	else if (temp == 3)
445	len += leng;	899	(*result)->data.dat_error = psiconv_sheet_error_value;
		900	else if (temp == 4)
		901	(*result)->data.dat_error = psiconv_sheet_error_reference;
		902	else if (temp == 5)
		903	(*result)->data.dat_error = psiconv_sheet_error_name;
		904	else if (temp == 6)
		905	(*result)->data.dat_error = psiconv_sheet_error_number;
		906	else if (temp == 7)
		907	(*result)->data.dat_error = psiconv_sheet_error_notavail;
		908	else {
		909	psiconv_warn(config,lev+2,off+len,"Unknown error code (default assumed)");
		910	psiconv_debug(config,lev+2,off+len,"Error code: %04x",temp);
		911	(*result)->data.dat_error = psiconv_sheet_error_none;
446	}	912	}
447		913	psiconv_debug(config,lev+2,off+len,"Cell contents: %04x",
448	if (temp & 0x02) {	914	(*result)->data.dat_error);
449	psiconv_progress(lev+3,off+len,"Going to read the character codes");
450	if (!((*result)->character = psiconv_basic_character_layout()))
451	goto ERROR2;
452	if ((res = psiconv_parse_character_layout_list(buf,lev+3,off+len,&leng,
453	(*result)->character)))
454	goto ERROR2;
455	len += leng;	915	len += 2;
456	}	916	} else if ((*result)->type == psiconv_cell_float) {
457		917	psiconv_progress(config,lev+2,off+len,"Going to read a float");
458	if (temp & 0x04) {	918	(*result)->data.dat_float =
459	/* TODO: default number format */	919	psiconv_read_float(config,buf,lev+2,off+len,&leng,&res);
460	psiconv_read_u8(buf,lev+2,off+len,&res);
461	if (res)
462	goto ERROR2;
463	len ++;
464	psiconv_read_u8(buf,lev+2,off+len,&res);
465	if (res)
466	goto ERROR2;
467	len ++;
468	psiconv_read_u8(buf,lev+2,off+len,&res);
469	if (res)
470	goto ERROR2;
471	len ++;
472	}
473	}
474
475	if ((*result)->calculated) {
476	psiconv_progress(lev+2,off+len,"Going to read the cell formula reference");
477	temp = psiconv_read_X(buf,lev+2,off+len,&leng,&res);
478	if (res)	920	if (res)
479	goto ERROR2;	921	goto ERROR2;
		922	psiconv_debug(config,lev+2,off+len,"Cell contents: %f",(*result)->data.dat_float);
		923	len += leng;
		924	} else if ((*result)->type == psiconv_cell_string) {
		925	psiconv_progress(config,lev+2,off+len,"Going to read a string");
		926	(*result)->data.dat_string =
		927	psiconv_read_string(config,buf,lev+2,off+len,&leng,&res);
		928	if (res)
		929	goto ERROR2;
		930	psiconv_debug(config,lev+2,off+len,"Cell contents: `%s'",
		931	(*result)->data.dat_string);
		932	len += leng;
		933	} else {
		934	psiconv_warn(config,lev+2,off+len,"Unknown Sheet Cell type: %02x",(*result)->type);
		935	res = PSICONV_E_PARSE;
		936	goto ERROR2;
		937	}
		938
		939	if (!((*result)->layout = psiconv_clone_cell_layout(
		940	psiconv_get_default_layout(row_default_layouts,
		941	col_default_layouts,
		942	default_layout,
		943	(*result)->row,
		944	(*result)->column))))
		945	goto ERROR2;
		946	if (has_layout) {
		947	if ((res = psiconv_parse_sheet_cell_layout(config,buf,lev+2,off+len,
		948	&leng,(*result)->layout)))
		949	goto ERROR2;
		950	len += leng;
		951	}
		952
		953	if ((*result)->calculated) {
		954	psiconv_progress(config,lev+2,off+len,"Going to read the cell formula reference");
		955	temp = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
		956	if (res)
		957	goto ERROR2;
480	psiconv_debug(lev+2,off+len,"Cell formula reference: %d",temp);	958	psiconv_debug(config,lev+2,off+len,"Cell formula reference: %d",temp);
481	len += leng;	959	len += leng;
482	(*result)->ref_formula = temp;	960	(*result)->ref_formula = temp;
483	}	961	}
484		962
485	if (length)	963	if (length)
486	*length = len;	964	*length = len;
487		965
488	psiconv_progress(lev,off+len-1,	966	psiconv_progress(config,lev,off+len-1,
489	"End of sheet cell structure (total length: %08x)", len);	967	"End of sheet cell structure (total length: %08x)", len);
490	return 0;	968	return 0;
491		969
492	ERROR2:	970	ERROR2:
493	psiconv_free_sheet_cell(*result);	971	psiconv_free_sheet_cell(*result);
494	ERROR1:	972	ERROR1:
495	psiconv_warn(lev+1,off,"Reading of Sheet Cell Structure failed");	973	psiconv_warn(config,lev+1,off,"Reading of Sheet Cell Structure failed");
496	if (length)	974	if (length)
497	*length = 0;	975	*length = 0;
498	if (!res)	976	if (!res)
499	return -PSICONV_E_NOMEM;	977	return -PSICONV_E_NOMEM;
500	else	978	else
501	return res;	979	return res;
502	}	980	}
503		981
504	int psiconv_parse_sheet_cell_list(const psiconv_buffer buf, int lev,	982	int psiconv_parse_sheet_cell_list(const psiconv_config config,
		983	const psiconv_buffer buf, int lev,
505	psiconv_u32 off, int *length,	984	psiconv_u32 off, int *length,
506	psiconv_sheet_cell_list *result)	985	psiconv_sheet_cell_list *result,
		986	const psiconv_sheet_cell_layout default_layout,
		987	const psiconv_sheet_line_list row_default_layouts,
		988	const psiconv_sheet_line_list col_default_layouts)
507	{	989	{
508	int res=0;	990	int res=0;
509	int len=0;	991	int len=0;
510	psiconv_u32 temp;	992	psiconv_u32 temp;
511	psiconv_sheet_cell cell;	993	psiconv_sheet_cell cell;
512	psiconv_u32 listlen,i;	994	psiconv_u32 listlen,i;
513	int leng;	995	int leng;
514		996
515	psiconv_progress(lev+1,off,"Going to read the sheet cells list");	997	psiconv_progress(config,lev+1,off,"Going to read the sheet cell list");
516	if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_cell_s))))	998	if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_cell_s))))
517	goto ERROR1;	999	goto ERROR1;
518		1000
519	psiconv_progress(lev+2,off+len,	1001	psiconv_progress(config,lev+2,off+len,
520	"Going to read the initial byte (%02x expected)",0x02);	1002	"Going to read the initial byte (%02x expected)",0x02);
521	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	1003	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
522	if (res)	1004	if (res)
523	goto ERROR2;	1005	goto ERROR2;
524	if (temp != 0x02) {	1006	if (temp != 0x02) {
525	psiconv_warn(lev+2,off+len,	1007	psiconv_warn(config,lev+2,off+len,
526	"Sheet cell list initial byte unknown value (ignored)");	1008	"Sheet cell list initial byte unknown value (ignored)");
527	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);	1009	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
528	}	1010	}
529	len ++;	1011	len ++;
530		1012
531	psiconv_progress(lev+2,off+len,	1013	psiconv_progress(config,lev+2,off+len,
532	"Going to read the initial byte (%02x expected)",0x00);	1014	"Going to read the initial byte (%02x expected)",0x00);
533	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	1015	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
534	if (res)	1016	if (res)
535	goto ERROR2;	1017	goto ERROR2;
536	if (temp != 0x00) {	1018	if (temp != 0x00) {
537	psiconv_warn(lev+2,off+len,	1019	psiconv_warn(config,lev+2,off+len,
538	"Sheet cell list initial byte unknown value (ignored)");	1020	"Sheet cell list initial byte unknown value (ignored)");
539	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);	1021	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
540	}	1022	}
541	len ++;	1023	len ++;
542		1024
543	psiconv_progress(lev+2,off+len,	1025	psiconv_progress(config,lev+2,off+len,
544	"Going to read the number of defined cells");	1026	"Going to read the number of defined cells");
545	listlen = psiconv_read_X(buf,lev+2,off+len,&leng,&res);	1027	listlen = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
546	if (res)	1028	if (res)
547	goto ERROR2;	1029	goto ERROR2;
548	psiconv_debug(lev+2,off+len,"Number of defined cells: %d",listlen);	1030	psiconv_debug(config,lev+2,off+len,"Number of defined cells: %d",listlen);
549	len += leng;	1031	len += leng;
550		1032
551	psiconv_progress(lev+2,off+len,"Going to read all cells");	1033	psiconv_progress(config,lev+2,off+len,"Going to read all cells");
552	for (i = 0; i < listlen; i++) {	1034	for (i = 0; i < listlen; i++) {
553	psiconv_progress(lev+3,off+len,"Going to read cell %d",i);	1035	psiconv_progress(config,lev+3,off+len,"Going to read cell %d",i);
554	if ((res = psiconv_parse_sheet_cell(buf,lev+3,off+len,&leng,&cell)))	1036	if ((res = psiconv_parse_sheet_cell(config,buf,lev+3,off+len,&leng,&cell,
		1037	default_layout,row_default_layouts,
		1038	col_default_layouts)))
555	goto ERROR2;	1039	goto ERROR2;
556	if ((res = psiconv_list_add(*result,cell)))	1040	if ((res = psiconv_list_add(*result,cell)))
557	goto ERROR3;	1041	goto ERROR3;
		1042	free(cell);
558	len += leng;	1043	len += leng;
559	}	1044	}
560		1045
561	if (length)	1046	if (length)
562	*length = len;	1047	*length = len;
563		1048
564	psiconv_progress(lev,off+len-1,	1049	psiconv_progress(config,lev,off+len-1,
565	"End of sheet cell list (total length: %08x)", len);	1050	"End of sheet cell list (total length: %08x)", len);
566	return 0;	1051	return 0;
567		1052
568	ERROR3:	1053	ERROR3:
569	psiconv_free_sheet_cell(cell);	1054	psiconv_free_sheet_cell(cell);
570	ERROR2:	1055	ERROR2:
571	psiconv_free_sheet_cell_list(*result);	1056	psiconv_free_sheet_cell_list(*result);
572	ERROR1:	1057	ERROR1:
573	psiconv_warn(lev+1,off,"Reading of Sheet Cells List failed");	1058	psiconv_warn(config,lev+1,off,"Reading of Sheet Cells List failed");
574	if (length)	1059	if (length)
575	*length = 0;	1060	*length = 0;
576	if (!res)	1061	if (!res)
577	return -PSICONV_E_NOMEM;	1062	return -PSICONV_E_NOMEM;
578	else	1063	else
579	return res;	1064	return res;
580	}	1065	}
581		1066
582		1067
583	int psiconv_parse_sheet_worksheet_section(const psiconv_buffer buf, int lev,	1068	int psiconv_parse_sheet_worksheet_list(const psiconv_config config,
		1069	const psiconv_buffer buf, int lev,
584	psiconv_u32 off, int *length,	1070	psiconv_u32 off, int *length,
585	psiconv_sheet_worksheet_section *result)	1071	psiconv_sheet_worksheet_list *result)
586	{	1072	{
		1073	psiconv_sheet_worksheet worksheet;
587	int res=0;	1074	int res=0;
588	psiconv_u32 temp,cells_off,grid_off;
589	int len=0;	1075	int len=0;
		1076	psiconv_u8 temp;
		1077	psiconv_u32 offset;
590	int leng;	1078	int leng,i,nr;
591		1079
592	/* TODO: this is the section that might be an XListE instead... */	1080	psiconv_progress(config,lev+1,off,"Going to read the worksheet list");
		1081	if (!(result = psiconv_list_new(sizeof(worksheet))))
		1082	goto ERROR1;
		1083
593	psiconv_progress(lev+2,off+len,	1084	psiconv_progress(config,lev+2,off+len,
594	"Going to read the initial bytes (%02x expected)",0x02);	1085	"Going to read the initial bytes (%02x expected)",0x02);
595	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	1086	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
596	if (res)
597	goto ERROR1;
598	if (temp != 0x04) {
599	psiconv_warn(lev+2,off+len,
600	"Sheet worksheet section initial byte unknown value (ignored)");
601	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
602	}
603	len ++;
604
605	psiconv_progress(lev+2,off+len,
606	"Going to read the initial bytes (%02x expected)",0x02);
607	temp = psiconv_read_u8(buf,lev+2,off+len,&res);
608	if (res)
609	goto ERROR1;
610	if (temp != 0x04) {
611	psiconv_warn(lev+2,off+len,
612	"Sheet worksheet section initial byte unknown value (ignored)");
613	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
614	}
615	len ++;
616
617	psiconv_progress(lev+2,off+len,
618	"Going to read the initial bytes (%02x expected)",0x00);
619	temp = psiconv_read_u8(buf,lev+2,off+len,&res);
620	if (res)
621	goto ERROR1;
622	if (temp != 0x04) {
623	psiconv_warn(lev+2,off+len,
624	"Sheet worksheet section initial byte unknown value (ignored)");
625	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
626	}
627	len ++;
628
629	psiconv_progress(lev+2,off+len,
630	"Going to read the offset of the Worksheet Section");
631	temp = psiconv_read_u32(buf,lev+2,off+len,&res);
632	if (res)
633	goto ERROR1;
634	psiconv_debug(lev+2,off+len,"Offset: %04x",temp);
635	len += 4;
636
637	len = 0;
638	off = temp;
639
640	/* this is the real worksheet section from here */
641
642	psiconv_progress(lev+1,off,"Going to read the sheet worksheet section");
643	if (!(result = malloc(sizeof(*result))))
644	goto ERROR1;
645
646	psiconv_progress(lev+2,off+len,
647	"Going to read the initial bytes (%02x expected)",0x04);
648	temp = psiconv_read_u8(buf,lev+2,off+len,&res);
649	if (res)
650	goto ERROR2;
651	if (temp != 0x04) {
652	psiconv_warn(lev+2,off+len,
653	"Worksheet section initial byte unknown value (ignored)");
654	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
655	}
656	len ++;
657
658	psiconv_progress(lev+2,off+len,
659	"Going to read the initial bytes (%02x expected)",0x01);
660	temp = psiconv_read_u8(buf,lev+2,off+len,&res);
661	if (res)
662	goto ERROR2;
663	if (temp != 0x01) {
664	psiconv_warn(lev+2,off+len,
665	"Worksheet section initial byte unknown value (ignored)");
666	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
667	}
668	len ++;
669
670	psiconv_progress(lev+2,off+len,
671	"Going to read the initial bytes (%02x expected)",0x02);
672	temp = psiconv_read_u8(buf,lev+2,off+len,&res);
673	if (res)	1087	if (res)
674	goto ERROR2;	1088	goto ERROR2;
675	if (temp != 0x02) {	1089	if (temp != 0x02) {
676	psiconv_warn(lev+2,off+len,	1090	psiconv_warn(config,lev+2,off+len,
677	"Worksheet section initial byte unknown value (ignored)");	1091	"Sheet worksheet list initial byte unknown value (ignored)");
678	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);	1092	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
679	}	1093	}
680	len ++;	1094	len ++;
681		1095
		1096	psiconv_progress(config,lev+2,off+len,"Going to read the list length");
		1097	nr = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
		1098	if (res)
		1099	goto ERROR2;
		1100	psiconv_debug(config,lev+2,off+len,"Length: %02x",nr);
		1101	len += leng;
		1102
682	psiconv_progress(lev+2,off+len,"Going to read the default formats flag");	1103	psiconv_progress(config,lev+2,off+len,"Going to read the list");
		1104	for (i=0 ; i < nr; i++) {
		1105	psiconv_progress(config,lev+3,off+len,"Going to read element %d",i);
		1106	psiconv_progress(config,lev+4,off+len,
		1107	"Going to read the initial byte (%02x expected)",0x00);
683	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	1108	temp = psiconv_read_u8(config,buf,lev+4,off+len,&res);
684	if (res)	1109	if (res)
685	goto ERROR2;
686	len ++;
687
688	if (temp & 0x01) {
689	if (!((*result)->paragraph = psiconv_basic_paragraph_layout()))
690	goto ERROR2;	1110	goto ERROR2;
691	psiconv_progress(lev+3,off+len,"Going to read the default paragraph codes");
692	if ((res = psiconv_parse_paragraph_layout_list(buf,lev+3,off+len,&leng,
693	(*result)->paragraph)))
694	goto ERROR2_1;
695	len += leng;
696	}
697
698	if (temp & 0x02) {	1111	if (temp != 0x00) {
699	psiconv_progress(lev+3,off+len,"Going to read the default character codes");	1112	psiconv_warn(config,lev+4,off+len,
700	if (!((*result)->character = psiconv_basic_character_layout()))	1113	"Sheet worksheet element initial byte unknown value (ignored)");
701	goto ERROR2_1;	1114	psiconv_debug(config,lev+4,off+len,"Initial byte: %02x",temp);
702	if ((res = psiconv_parse_character_layout_list(buf,lev+3,off+len,&leng,
703	(*result)->character)))
704	goto ERROR2_2;
705	len += leng;
706	}	1115	}
707		1116	len ++;
708	if (temp & 0x04) {	1117
709	/* TODO: default number format */	1118	psiconv_progress(config,lev+4,off+len,"Going to read the worksheet offset");
710	psiconv_read_u8(buf,lev+2,off+len,&res);	1119	offset = psiconv_read_u32(config,buf,lev+2,off+len,&res);
711	if (res)	1120	if (res)
712	goto ERROR2_3;	1121	goto ERROR2;
		1122	psiconv_debug(config,lev+4,off+len,"Offset: %08x",offset);
713	len ++;	1123	len += 4;
714	psiconv_read_u8(buf,lev+2,off+len,&res);	1124
715	if (res)	1125	if ((res = psiconv_parse_sheet_worksheet(config,buf,lev+4,offset,NULL,
		1126	&worksheet)))
716	goto ERROR2_3;	1127	goto ERROR2;
717	len ++;	1128	if ((res = psiconv_list_add(*result,worksheet)))
718	psiconv_read_u8(buf,lev+2,off+len,&res);
719	if (res)
720	goto ERROR2_3;	1129	goto ERROR3;
721	len ++;	1130	free(worksheet);
722	}
723		1131	}
724	psiconv_progress(lev+2,off+len,
725	"Going to read the offset of the 1st ??? Section");
726	temp = psiconv_read_u32(buf,lev+2,off+len,&res);
727	if (res)
728	goto ERROR2;
729	psiconv_debug(lev+2,off+len,"Offset: %04x",temp);
730	len += 4;
731		1132
732	psiconv_progress(lev+2,off+len,
733	"Going to read the offset of the 2nd ??? Section");
734	temp = psiconv_read_u32(buf,lev+2,off+len,&res);
735	if (res)
736	goto ERROR2;
737	psiconv_debug(lev+2,off+len,"Offset: %04x",temp);
738	len += 4;
739
740	psiconv_progress(lev+2,off+len,
741	"Going to read the offset of the Cells List");
742	cells_off = psiconv_read_u32(buf,lev+2,off+len,&res);
743	if (res)
744	goto ERROR2;
745	psiconv_debug(lev+2,off+len,"Offset: %04x",cells_off);
746	len += 4;
747
748	psiconv_progress(lev+2,off+len,
749	"Going to read the offset of the Grid Section");
750	grid_off = psiconv_read_u32(buf,lev+2,off+len,&res);
751	if (res)
752	goto ERROR2;
753	psiconv_debug(lev+2,off+len,"Offset: %04x",grid_off);
754	len += 4;
755
756	psiconv_progress(lev+2,off+len,
757	"Going to read the offset of the 3rd ??? Section");
758	temp = psiconv_read_u32(buf,lev+2,off+len,&res);
759	if (res)
760	goto ERROR2;
761	psiconv_debug(lev+2,off+len,"Offset: %04x",temp);
762	len += 4;
763
764	psiconv_progress(lev+2,off+len,"Going to read the cells list");
765	if ((res = psiconv_parse_sheet_cell_list(buf,lev+2,cells_off,NULL,
766	&(*result)->cells)))
767	goto ERROR2;
768
769
770	/* TODO: parse grid section */
771
772	if (length)	1133	if (length)
773	*length = len;	1134	*length = len;
774		1135
775	psiconv_progress(lev,off+len-1,	1136	psiconv_progress(config,lev,off+len-1,
776	"End of sheet worksheet section (total length: %08x)", len);	1137	"End of worksheet list (total length: %08x)", len);
		1138
777	return 0;	1139	return 0;
778		1140
779	ERROR2_3:	1141	ERROR3:
780	psiconv_free_numberformat((*result)->numberformat);	1142	psiconv_free_sheet_worksheet(worksheet);
781	ERROR2_2:
782	psiconv_free_character_layout((*result)->character);
783	ERROR2_1:
784	psiconv_free_paragraph_layout((*result)->paragraph);
785	goto ERROR2;
786
787	ERROR2:	1143	ERROR2:
788	free (*result);	1144	psiconv_free_sheet_worksheet_list(*result);
789	ERROR1:	1145	ERROR1:
790	psiconv_warn(lev+1,off,"Reading of Sheet Worksheet Section failed");	1146	psiconv_warn(config,lev+1,off,"Reading of worksheet list failed");
791	if (length)	1147	if (length)
792	*length = 0;	1148	*length = 0;
793	if (!res)	1149	if (!res)
794	return -PSICONV_E_NOMEM;	1150	return -PSICONV_E_NOMEM;
795	else	1151	else
796	return res;	1152	return res;
797	}	1153	}
798		1154
		1155	int psiconv_parse_sheet_cell_layout(const psiconv_config config,
		1156	const psiconv_buffer buf, int lev,
		1157	psiconv_u32 off, int *length,
		1158	psiconv_sheet_cell_layout result)
799		1159
		1160	{
		1161	int res=0;
		1162	int len=0;
		1163	int leng;
		1164	psiconv_u8 temp;
		1165
		1166	psiconv_progress(config,lev+1,off,"Going to read a sheet cell layout");
		1167
		1168	psiconv_progress(config,lev+2,off+len,
		1169	"Going to read the first byte (%02x expected)",0x02);
		1170	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		1171	if (res)
		1172	goto ERROR1;
		1173	if (temp != 0x02) {
		1174	psiconv_warn(config,lev+2,off+len,
		1175	"Worksheet section initial byte unknown value (ignored)");
		1176	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
		1177	}
		1178	len ++;
		1179
		1180	psiconv_progress(config,lev+2,off+len,"Going to read the default formats flag");
		1181	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		1182	if (res)
		1183	goto ERROR1;
		1184	len ++;
		1185
		1186	if (temp & 0x01) {
		1187	psiconv_progress(config,lev+3,off+len,"Going to read the default paragraph codes");
		1188	if ((res = psiconv_parse_paragraph_layout_list(config,buf,lev+3,off+len,&leng,
		1189	result->paragraph)))
		1190	goto ERROR1;
		1191	len += leng;
		1192	}
		1193
		1194	if (temp & 0x02) {
		1195	psiconv_progress(config,lev+3,off+len,"Going to read the default character codes");
		1196	if ((res = psiconv_parse_character_layout_list(config,buf,lev+3,off+len,&leng,
		1197	result->character)))
		1198	goto ERROR1;
		1199	len += leng;
		1200	}
		1201
		1202	if (temp & 0x04) {
		1203	psiconv_progress(config,lev+3,off+len, "Going to read the default number format");
		1204	psiconv_parse_sheet_numberformat(config,buf,lev+3,off+len,&leng,
		1205	result->numberformat);
		1206	len += leng;
		1207	}
		1208
		1209	if (length)
		1210	*length = len;
		1211
		1212	psiconv_progress(config,lev,off+len-1,
		1213	"End of sheet cell layout (total length: %08x)", len);
		1214
		1215	return 0;
		1216
		1217	ERROR1:
		1218	psiconv_warn(config,lev+1,off,"Reading of sheet cell layout failed");
		1219	if (length)
		1220	*length = 0;
		1221	if (!res)
		1222	return -PSICONV_E_NOMEM;
		1223	else
		1224	return res;
		1225	}
		1226
		1227
		1228	int psiconv_parse_sheet_worksheet(const psiconv_config config,
		1229	const psiconv_buffer buf, int lev,
		1230	psiconv_u32 off, int *length,
		1231	psiconv_sheet_worksheet *result)
		1232	{
		1233	int res=0;
		1234	psiconv_u32 temp,cells_off,grid_off,rows_off,cols_off,unknown_off;
		1235	int len=0;
		1236	int leng;
		1237
		1238	psiconv_progress(config,lev+1,off,"Going to read the sheet worksheet section");
		1239	if (!(result = malloc(sizeof(*result))))
		1240	goto ERROR1;
		1241
		1242	psiconv_progress(config,lev+2,off+len,
		1243	"Going to read the initial bytes (%02x expected)",0x04);
		1244	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		1245	if (res)
		1246	goto ERROR2;
		1247	if (temp != 0x04) {
		1248	psiconv_warn(config,lev+2,off+len,
		1249	"Worksheet section initial byte unknown value (ignored)");
		1250	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
		1251	}
		1252	len ++;
		1253
		1254	psiconv_progress(config,lev+2,off+len, "Going to read the flags byte");
		1255	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		1256	if (res)
		1257	goto ERROR2;
		1258	psiconv_debug(config,lev+2,off+len,"Flags byte: %02x",temp);
		1259	(*result)->show_zeros = (temp & 0x01)?psiconv_bool_true:psiconv_bool_false;
		1260	if (temp & 0xfe) {
		1261	psiconv_warn(config,lev+2,off+len,
		1262	"Worksheet section flags byte unknown bits (ignored)");
		1263	}
		1264	len ++;
		1265
		1266	psiconv_progress(config,lev+2,off+len,"Going to read the default cell layout");
		1267	if (!((*result)->default_layout = psiconv_basic_cell_layout()))
		1268	goto ERROR2;
		1269	if ((res = psiconv_parse_sheet_cell_layout(config,buf,lev+2,off+len,&leng,
		1270	(*result)->default_layout)))
		1271	goto ERROR3;
		1272	len += leng;
		1273
		1274	psiconv_progress(config,lev+2,off+len,
		1275	"Going to read the offset of the row defaults Section");
		1276	rows_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		1277	if (res)
		1278	goto ERROR3;
		1279	psiconv_debug(config,lev+2,off+len,"Offset: %04x",rows_off);
		1280	len += 4;
		1281
		1282	psiconv_progress(config,lev+2,off+len,
		1283	"Going to read the offset of the column defaults Section");
		1284	cols_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		1285	if (res)
		1286	goto ERROR3;
		1287	psiconv_debug(config,lev+2,off+len,"Offset: %04x",cols_off);
		1288	len += 4;
		1289
		1290	psiconv_progress(config,lev+2,off+len,
		1291	"Going to read the offset of the Cells List");
		1292	cells_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		1293	if (res)
		1294	goto ERROR3;
		1295	psiconv_debug(config,lev+2,off+len,"Offset: %04x",cells_off);
		1296	len += 4;
		1297
		1298	psiconv_progress(config,lev+2,off+len,
		1299	"Going to read the offset of the Grid Section");
		1300	grid_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		1301	if (res)
		1302	goto ERROR3;
		1303	psiconv_debug(config,lev+2,off+len,"Offset: %04x",grid_off);
		1304	len += 4;
		1305
		1306	psiconv_progress(config,lev+2,off+len,
		1307	"Going to read the offset of the 3rd ??? Section");
		1308	unknown_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		1309	if (res)
		1310	goto ERROR3;
		1311	psiconv_debug(config,lev+2,off+len,"Offset: %04x",unknown_off);
		1312	len += 4;
		1313
		1314	psiconv_progress(config,lev+2,off+len,
		1315	"Going to read a long of the 3rd ??? Section "
		1316	"(%08x expected)",0x00);
		1317	temp = psiconv_read_u32(config,buf,lev+2,unknown_off,&res);
		1318	if (res)
		1319	goto ERROR3;
		1320	if (temp != 0x00) {
		1321	psiconv_warn(config,lev+2,unknown_off,
		1322	"Unknown worksheet subsection has unknown contents (ignored)");
		1323	psiconv_debug(config,lev+2,unknown_off,"Offset: %04x",temp);
		1324	}
		1325	len += 4;
		1326
		1327	psiconv_progress(config,lev+2,off+len,"Going to read the row defaults");
		1328	if ((res = psiconv_parse_sheet_line_list(config,buf,lev+2,rows_off,NULL,
		1329	&(*result)->row_default_layouts,
		1330	(*result)->default_layout)))
		1331	goto ERROR3;
		1332
		1333	psiconv_progress(config,lev+2,off+len,"Going to read the column defaults");
		1334	if ((res = psiconv_parse_sheet_line_list(config,buf,lev+2,cols_off,NULL,
		1335	&(*result)->col_default_layouts,
		1336	(*result)->default_layout)))
		1337	goto ERROR4;
		1338
		1339	psiconv_progress(config,lev+2,off+len,"Going to read the cells list");
		1340	if ((res = psiconv_parse_sheet_cell_list(config,buf,lev+2,cells_off,NULL,
		1341	&(*result)->cells,
		1342	(*result)->default_layout,
		1343	(*result)->row_default_layouts,
		1344	(*result)->col_default_layouts)))
		1345	goto ERROR5;
		1346
		1347
		1348	psiconv_progress(config,lev+2,off+len,"Going to read the grid section");
		1349	if ((res = psiconv_parse_sheet_grid_section(config,buf,lev+2,grid_off,NULL,
		1350	&(*result)->grid)))
		1351	goto ERROR6;
		1352
		1353
		1354
		1355	if (length)
		1356	*length = len;
		1357
		1358	psiconv_progress(config,lev,off+len-1,
		1359	"End of sheet worksheet section (total length: %08x)", len);
		1360	return 0;
		1361
		1362	ERROR6:
		1363	psiconv_free_sheet_cell_list((*result)->cells);
		1364	ERROR5:
		1365	psiconv_free_sheet_line_list((*result)->col_default_layouts);
		1366	ERROR4:
		1367	psiconv_free_sheet_line_list((*result)->row_default_layouts);
		1368	ERROR3:
		1369	psiconv_free_sheet_cell_layout((*result)->default_layout);
		1370	ERROR2:
		1371	free (*result);
		1372	ERROR1:
		1373	psiconv_warn(config,lev+1,off,"Reading of Sheet Worksheet Section failed");
		1374	if (length)
		1375	*length = 0;
		1376	if (!res)
		1377	return -PSICONV_E_NOMEM;
		1378	else
		1379	return res;
		1380	}
		1381
		1382	int psiconv_parse_sheet_line(const psiconv_config config,
		1383	const psiconv_buffer buf, int lev,
		1384	psiconv_u32 off, int *length,
		1385	psiconv_sheet_line *result,
		1386	const psiconv_sheet_cell_layout default_layout)
		1387	{
		1388	int res=0;
		1389	int len=0;
		1390	int leng;
		1391
		1392
		1393	psiconv_progress(config,lev+1,off,"Going to read a sheet line");
		1394	if (!(result = malloc(sizeof(*result))))
		1395	goto ERROR1;
		1396
		1397	psiconv_progress(config,lev+2,off+len,"Going to read the line number");
		1398	(*result)->position = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
		1399	if (res)
		1400	goto ERROR2;
		1401	psiconv_debug(config,lev+2,off+len,"Line number: %d\n",(*result)->position);
		1402	len += leng;
		1403
		1404	if (!((*result)->layout = psiconv_clone_cell_layout(default_layout)))
		1405	goto ERROR2;
		1406	if ((res = psiconv_parse_sheet_cell_layout(config,buf,lev+2,off+len,
		1407	&leng,(*result)->layout)))
		1408	goto ERROR3;
		1409	len += leng;
		1410
		1411	if (length)
		1412	*length = len;
		1413
		1414	psiconv_progress(config,lev,off+len-1,
		1415	"End of the sheet line (total length: %08x)", len);
		1416	return 0;
		1417
		1418	ERROR3:
		1419	psiconv_free_sheet_cell_layout((*result)->layout);
		1420	ERROR2:
		1421	free (*result);
		1422	ERROR1:
		1423	psiconv_warn(config,lev+1,off,"Reading of the sheet line failed");
		1424	if (length)
		1425	*length = 0;
		1426	if (!res)
		1427	return -PSICONV_E_NOMEM;
		1428	else
		1429	return res;
		1430	}
		1431
		1432
		1433	int psiconv_parse_sheet_line_list(const psiconv_config config,
		1434	const psiconv_buffer buf, int lev,
		1435	psiconv_u32 off, int *length,
		1436	psiconv_sheet_line_list *result,
		1437	const psiconv_sheet_cell_layout default_layout)
		1438	{
		1439	int res=0;
		1440	int len=0;
		1441	psiconv_u32 temp;
		1442	psiconv_sheet_line line;
		1443	psiconv_u32 listlen,i;
		1444	int leng;
		1445
		1446	psiconv_progress(config,lev+1,off,"Going to read the sheet line list");
		1447	if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_line_s))))
		1448	goto ERROR1;
		1449
		1450	psiconv_progress(config,lev+2,off+len,
		1451	"Going to read the initial byte (%02x expected)",0x02);
		1452	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		1453	if (res)
		1454	goto ERROR2;
		1455	if (temp != 0x02) {
		1456	psiconv_warn(config,lev+2,off+len,
		1457	"Sheet line list initial byte unknown value (ignored)");
		1458	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
		1459	}
		1460	len ++;
		1461
		1462	psiconv_progress(config,lev+2,off+len,
		1463	"Going to read the number of defined lines");
		1464	listlen = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
		1465	if (res)
		1466	goto ERROR2;
		1467	psiconv_debug(config,lev+2,off+len,"Number of defined lines: %d",listlen);
		1468	len += leng;
		1469
		1470	psiconv_progress(config,lev+2,off+len,"Going to read all lines");
		1471	for (i = 0; i < listlen; i++) {
		1472	psiconv_progress(config,lev+3,off+len,"Going to read line %d",i);
		1473	if ((res = psiconv_parse_sheet_line(config,buf,lev+3,off+len,&leng,&line,
		1474	default_layout)))
		1475	goto ERROR2;
		1476	if ((res = psiconv_list_add(*result,line)))
		1477	goto ERROR3;
		1478	free(line);
		1479	len += leng;
		1480	}
		1481
		1482	if (length)
		1483	*length = len;
		1484
		1485	psiconv_progress(config,lev,off+len-1,
		1486	"End of sheet line list (total length: %08x)", len);
		1487	return 0;
		1488
		1489	ERROR3:
		1490	psiconv_free_sheet_line(line);
		1491	ERROR2:
		1492	psiconv_free_sheet_line_list(*result);
		1493	ERROR1:
		1494	psiconv_warn(config,lev+1,off,"Reading of Sheet Line List failed");
		1495	if (length)
		1496	*length = 0;
		1497	if (!res)
		1498	return -PSICONV_E_NOMEM;
		1499	else
		1500	return res;
		1501	}
		1502
		1503	int psiconv_parse_sheet_variable(const psiconv_config config,
		1504	const psiconv_buffer buf, int lev,
		1505	psiconv_u32 off, int *length,
		1506	psiconv_sheet_variable *result)
		1507	{
		1508	int res=0;
		1509	int len=0;
		1510	psiconv_u32 marker;
		1511	int leng;
		1512
		1513	psiconv_progress(config,lev+1,off,"Going to read a sheet variable");
		1514	if (!(result = malloc(sizeof(*result))))
		1515	goto ERROR1;
		1516
		1517	psiconv_progress(config,lev+2,off+len, "Going to read the variable name");
		1518	(*result)->name = psiconv_read_string(config,buf,lev+2,off+len,&leng,&res);
		1519	if (res)
		1520	goto ERROR2;
		1521	len += leng;
		1522
		1523	psiconv_progress(config,lev+2,off+len,"Going to read the type marker");
		1524	marker = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		1525	if (res)
		1526	goto ERROR3;
		1527	psiconv_debug(config,lev+2,off+len,"Marker: %02x",marker);
		1528	len ++;
		1529
		1530	if (marker == 0x00) {
		1531	(*result)->type = psiconv_var_int;
		1532	psiconv_progress(config,lev+2,off+len,"Going to read a signed integer");
		1533	(*result)->data.dat_int = psiconv_read_sint(config,buf,lev+2,off+len,&leng,&res);
		1534	if (res)
		1535	goto ERROR3;
		1536	psiconv_debug(config,lev+2,off+len,"Value: %d",(*result)->data.dat_int);
		1537	len += leng;
		1538	} else if (marker == 0x01) {
		1539	(*result)->type = psiconv_var_float;
		1540	psiconv_progress(config,lev+2,off+len,"Going to read a floating point number");
		1541	(*result)->data.dat_float = psiconv_read_float(config,buf,lev+2,off+len,&leng,
		1542	&res);
		1543	if (res)
		1544	goto ERROR3;
		1545	psiconv_debug(config,lev+2,off+len,"Value: %f",(*result)->data.dat_float);
		1546	len += leng;
		1547	} else if (marker == 0x02) {
		1548	(*result)->type = psiconv_var_string;
		1549	psiconv_progress(config,lev+2,off+len,"Going to read a string");
		1550	(*result)->data.dat_string = psiconv_read_string(config,buf,lev+2,off+len,&leng,
		1551	&res);
		1552	if (res)
		1553	goto ERROR3;
		1554	len += leng;
		1555	} else if (marker == 0x03) {
		1556	(*result)->type = psiconv_var_cellref;
		1557	psiconv_progress(config,lev+2,off+len,"Going to read a cell reference");
		1558	(*result)->data.dat_cellref = psiconv_read_var_cellref(config,buf,lev+2,off+len,
		1559	&leng, &res);
		1560	if (res)
		1561	goto ERROR3;
		1562	len += leng;
		1563	} else if (marker == 0x04) {
		1564	(*result)->type = psiconv_var_cellblock;
		1565	psiconv_progress(config,lev+2,off+len,"Going to read a cell block reference");
		1566	(*result)->data.dat_cellblock = psiconv_read_var_cellblock(config,buf,lev+2,
		1567	off+len,
		1568	&leng, &res);
		1569	if (res)
		1570	goto ERROR3;
		1571	len += leng;
		1572	} else {
		1573	psiconv_warn(config,lev+2,off+len,"Sheet variable unknown type marker");
		1574	res = -PSICONV_E_PARSE;
		1575	goto ERROR3;
		1576	}
		1577
		1578	psiconv_progress(config,lev+2,off+len,"Going to read the variable number");
		1579	(*result)->number = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		1580	if (res)
		1581	goto ERROR4;
		1582	psiconv_debug(config,lev+2,off+len,"Number: %08x",(*result)->number);
		1583	len += 4;
		1584
		1585	if (length)
		1586	*length = len;
		1587
		1588	psiconv_progress(config,lev,off+len-1,
		1589	"End of sheet variable (total length: %08x)", len);
		1590	return 0;
		1591
		1592	ERROR4:
		1593	if ((*result)->type == psiconv_var_string)
		1594	free((*result)->data.dat_string);
		1595	ERROR3:
		1596	free((*result)->name);
		1597	ERROR2:
		1598	free (*result);
		1599	ERROR1:
		1600	psiconv_warn(config,lev+1,off,"Reading of Sheet Variable failed");
		1601	if (length)
		1602	*length = 0;
		1603	if (!res)
		1604	return -PSICONV_E_NOMEM;
		1605	else
		1606	return res;
		1607	}
		1608
		1609
		1610	int psiconv_parse_sheet_variable_list(const psiconv_config config,
		1611	const psiconv_buffer buf, int lev,
		1612	psiconv_u32 off, int *length,
		1613	psiconv_sheet_variable_list *result)
		1614	{
		1615	int res=0;
		1616	int len=0;
		1617	psiconv_u32 temp;
		1618	psiconv_sheet_variable variable;
		1619	psiconv_u32 listlen,i;
		1620	int leng;
		1621
		1622	psiconv_progress(config,lev+1,off,"Going to read the sheet variable list");
		1623	if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_variable_s))))
		1624	goto ERROR1;
		1625
		1626	psiconv_progress(config,lev+2,off+len,
		1627	"Going to read the initial byte (%02x expected)",0x02);
		1628	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		1629	if (res)
		1630	goto ERROR2;
		1631	if (temp != 0x02) {
		1632	psiconv_warn(config,lev+2,off+len,
		1633	"Sheet variable list initial byte unknown value (ignored)");
		1634	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
		1635	}
		1636	len ++;
		1637
		1638	psiconv_progress(config,lev+2,off+len,
		1639	"Going to read the number of variables");
		1640	listlen = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
		1641	if (res)
		1642	goto ERROR2;
		1643	psiconv_debug(config,lev+2,off+len,"Number of variables: %d",listlen);
		1644	len += leng;
		1645
		1646	psiconv_progress(config,lev+2,off+len,"Going to read all variables");
		1647	for (i = 0; i < listlen; i++) {
		1648	psiconv_progress(config,lev+3,off+len,"Going to read variable %d",i);
		1649	if ((res = psiconv_parse_sheet_variable(config,buf,lev+3,off+len,&leng,&variable)))
		1650	goto ERROR2;
		1651	if ((res = psiconv_list_add(*result,variable)))
		1652	goto ERROR3;
		1653	len += leng;
		1654	}
		1655
		1656	if (length)
		1657	*length = len;
		1658
		1659	psiconv_progress(config,lev,off+len-1,
		1660	"End of sheet variabels list (total length: %08x)", len);
		1661	return 0;
		1662
		1663	ERROR3:
		1664	psiconv_free_sheet_variable(variable);
		1665	ERROR2:
		1666	psiconv_list_free(*result);
		1667	ERROR1:
		1668	psiconv_warn(config,lev+1,off,"Reading of Sheet Variable list failed");
		1669	if (length)
		1670	*length = 0;
		1671	if (!res)
		1672	return -PSICONV_E_NOMEM;
		1673	else
		1674	return res;
		1675	}
		1676
		1677	int psiconv_parse_sheet_grid_section(const psiconv_config config,
		1678	const psiconv_buffer buf, int lev,
		1679	psiconv_u32 off, int *length,
		1680	psiconv_sheet_grid_section *result)
		1681	{
		1682	int res=0,i;
		1683	int len=0,leng;
		1684	psiconv_u32 temp;
		1685
		1686	psiconv_progress(config,lev+1,off,"Going to read the sheet grid section");
		1687	if (!(result = malloc(sizeof(*result))))
		1688	goto ERROR1;
		1689
		1690	psiconv_progress(config,lev+2,off+len, "Going to read the first flags byte");
		1691	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		1692	if (res)
		1693	goto ERROR2;
		1694	(*result)->show_column_titles = temp&0x01?psiconv_bool_true:
		1695	psiconv_bool_false;
		1696	psiconv_debug(config,lev+2,off+len,
		1697	"Show column titles: %s",
		1698	(*result)->show_column_titles?"true":"false");
		1699	(*result)->show_row_titles = temp&0x02?psiconv_bool_true:psiconv_bool_false;
		1700	psiconv_debug(config,lev+2,off+len,
		1701	"Show row titles: %s",
		1702	(*result)->show_row_titles?"true":"false");
		1703	(*result)->show_vertical_grid = temp&0x04?psiconv_bool_true:
		1704	psiconv_bool_false;
		1705	psiconv_debug(config,lev+2,off+len,
		1706	"Show vertical grid: %s",
		1707	(*result)->show_vertical_grid?"true":"false");
		1708	(*result)->show_horizontal_grid = temp&0x07?psiconv_bool_true:
		1709	psiconv_bool_false;
		1710	psiconv_debug(config,lev+2,off+len,
		1711	"Show horizontal grid: %s",
		1712	(*result)->show_horizontal_grid?"true":"false");
		1713	(*result)->freeze_rows = temp&0x80?psiconv_bool_true:psiconv_bool_false;
		1714	psiconv_debug(config,lev+2,off+len,
		1715	"Freeze rows: %s",
		1716	(*result)->freeze_rows?"true":"false");
		1717	if ((temp & 0x70) != 0x30) {
		1718	psiconv_warn(config,lev+2,off+len,
		1719	"Grid section first flag byte has unknown bits (ignored)");
		1720	psiconv_debug(config,lev+2,off+len,"Bits: %02x (%02x expected)",temp&0x70,0x30);
		1721	}
		1722	len ++;
		1723
		1724	psiconv_progress(config,lev+2,off+len, "Going to read the second flags byte");
		1725	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		1726	if (res)
		1727	goto ERROR2;
		1728	(*result)->freeze_columns = temp&0x01?psiconv_bool_true:psiconv_bool_false;
		1729	psiconv_debug(config,lev+2,off+len,
		1730	"Freeze columns: %s", (*result)->freeze_columns?"true":"false");
		1731	if ((temp & 0xfe) != 0x80) {
		1732	psiconv_warn(config,lev+2,off+len,
		1733	"Grid section second flag byte has unknown bits (ignored)");
		1734	psiconv_debug(config,lev+2,off+len,"Bits: %02x (%02x expected)",temp&0xfe,0x80);
		1735	}
		1736	len ++;
		1737
		1738	psiconv_progress(config,lev+2,off+len,
		1739	"Going to an unknown byte (%02x expected)",0x90);
		1740	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		1741	if (res)
		1742	goto ERROR2;
		1743	if (temp != 0x90) {
		1744	psiconv_warn(config,lev+2,off+len,
		1745	"Grid section third byte unknown value (ignored)");
		1746	psiconv_debug(config,lev+2,off+len,"Value: %02x",temp);
		1747	}
		1748	len ++;
		1749
		1750	psiconv_progress(config,lev+2,off+len, "Going to read the fourth flags byte");
		1751	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		1752	if (res)
		1753	goto ERROR2;
		1754	(*result)->show_page_breaks = temp&0x04?psiconv_bool_true:psiconv_bool_false;
		1755	psiconv_debug(config,lev+2,off+len,
		1756	"Show page breaks: %s",
		1757	(*result)->show_page_breaks?"true":"false");
		1758	if ((temp & 0xfc) != 0x00) {
		1759	psiconv_warn(config,lev+2,off+len,
		1760	"Grid section fourth flag byte has unknown bits (ignored)");
		1761	psiconv_debug(config,lev+2,off+len,"Bits: %02x (%02x expected)",temp&0xfc,0x00);
		1762	}
		1763	len ++;
		1764
		1765	psiconv_progress(config,lev+2,off+len,"Going to read the first visible row");
		1766	(*result)->first_row = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		1767	if (res)
		1768	goto ERROR2;
		1769	psiconv_debug(config,lev+2,off+len,"First row: %d",(*result)->first_row);
		1770	len += 4;
		1771
		1772	psiconv_progress(config,lev+2,off+len,"Going to read the first visible column");
		1773	(*result)->first_column = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		1774	if (res)
		1775	goto ERROR2;
		1776	psiconv_debug(config,lev+2,off+len,"First column: %d",(*result)->first_column);
		1777	len += 4;
		1778
		1779	psiconv_progress(config,lev+2,off+len,"Going to read the last visible row");
		1780	(*result)->last_row = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		1781	if (res)
		1782	goto ERROR2;
		1783	psiconv_debug(config,lev+2,off+len,"Last row: %d",(*result)->last_row);
		1784	len += 4;
		1785
		1786	psiconv_progress(config,lev+2,off+len,"Going to read the last visible column");
		1787	(*result)->last_column = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		1788	if (res)
		1789	goto ERROR2;
		1790	psiconv_debug(config,lev+2,off+len,"Last column: %d",(*result)->last_column);
		1791	len += 4;
		1792
		1793	psiconv_progress(config,lev+2,off+len,"Going to read the default row height");
		1794	(*result)->default_row_height = psiconv_read_length(config,buf,lev+2,off+len,
		1795	&leng,&res);
		1796	if (res)
		1797	goto ERROR2;
		1798	psiconv_debug(config,lev+2,off+len,"Default row height: %f",
		1799	(*result)->default_row_height);
		1800	len += leng;
		1801
		1802	psiconv_progress(config,lev+2,off+len,"Going to read the row heights list");
		1803	if ((res = psiconv_parse_sheet_grid_size_list(config,buf,lev+2,off+len,&leng,
		1804	&(*result)->row_heights)))
		1805	goto ERROR2;
		1806	len += leng;
		1807
		1808	psiconv_progress(config,lev+2,off+len,"Going to read the default column height");
		1809	(*result)->default_column_width = psiconv_read_length(config,buf,lev+2,off+len,
		1810	&leng,&res);
		1811	if (res)
		1812	goto ERROR3;
		1813	psiconv_debug(config,lev+2,off+len,"Default column width: %f",
		1814	(*result)->default_column_width);
		1815	len += leng;
		1816
		1817	psiconv_progress(config,lev+2,off+len,"Going to read the column heights list");
		1818	if ((res = psiconv_parse_sheet_grid_size_list(config,buf,lev+2,off+len,&leng,
		1819	&(*result)->column_heights)))
		1820	goto ERROR3;
		1821	len += leng;
		1822
		1823	psiconv_progress(config,lev+2,off+len,
		1824	"Going to read an unknown word (%04x expected)",0x00);
		1825	temp = psiconv_read_u16(config,buf,lev+2,off+len,&res);
		1826	if (res)
		1827	goto ERROR4;
		1828	if (temp != 0x00) {
		1829	psiconv_warn(config,lev+2,off+len,
		1830	"Grid section unknown word has unknown value (ignored)");
		1831	psiconv_debug(config,lev+2,off+len,"Value: %04x",temp);
		1832	}
		1833	len += 2;
		1834
		1835	psiconv_progress(config,lev+2,off+len,"Going to read the row breaks list");
		1836	if ((res = psiconv_parse_sheet_grid_break_list(config,buf,lev+2,off+len,&leng,
		1837	&(*result)->row_page_breaks)))
		1838	goto ERROR4;
		1839	len += leng;
		1840
		1841	psiconv_progress(config,lev+2,off+len,"Going to read the column breaks list");
		1842	if ((res = psiconv_parse_sheet_grid_break_list(config,buf,lev+2,off+len,&leng,
		1843	&(*result)->column_page_breaks)))
		1844	goto ERROR5;
		1845	len += leng;
		1846
		1847
		1848	psiconv_progress(config,lev+2,off+len,
		1849	"Going to read 22 unknown bytes (%02x expected)",0x00);
		1850	for (i = 0; i < 22 ; i++) {
		1851	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		1852	if (res)
		1853	goto ERROR6;
		1854	if (temp != 0x00) {
		1855	psiconv_warn(config,lev+2,off+len,
		1856	"Grid section unknown byte %d has unknown value (ignored)",
		1857	i);
		1858	psiconv_debug(config,lev+2,off+len,"Value: %02x",temp);
		1859	}
		1860	len += 1;
		1861	}
		1862
		1863	if ((result)->freeze_rows \|\| (result)->freeze_columns) {
		1864
		1865	psiconv_progress(config,lev+2,off+len,"Going to read number of frozen rows");
		1866	(*result)->frozen_rows = psiconv_read_u32(config,buf,lev+2,off+len, &res);
		1867	if (res)
		1868	goto ERROR6;
		1869	psiconv_debug(config,lev+2,off+len,"Number of frozen rows: %d",
		1870	(*result)->frozen_rows);
		1871	len += leng;
		1872
		1873	psiconv_progress(config,lev+2,off+len,"Going to read number of frozen columns");
		1874	(*result)->frozen_columns = psiconv_read_u32(config,buf,lev+2,off+len, &res);
		1875	if (res)
		1876	goto ERROR6;
		1877	psiconv_debug(config,lev+2,off+len,"Number of frozen columns: %d",
		1878	(*result)->frozen_columns);
		1879	len += leng;
		1880
		1881	psiconv_progress(config,lev+2,off+len,"Going to read first unfrozen row");
		1882	(*result)->first_unfrozen_row_displayed = psiconv_read_u32(config,buf,lev+2,
		1883	off+len, &res);
		1884	if (res)
		1885	goto ERROR6;
		1886	psiconv_debug(config,lev+2,off+len,"First row: %d",
		1887	(*result)->first_unfrozen_row_displayed);
		1888	len += leng;
		1889
		1890	psiconv_progress(config,lev+2,off+len,"Going to read first unfrozen column");
		1891	(*result)->first_unfrozen_column_displayed = psiconv_read_u32(config,buf,lev+2,
		1892	off+len,&res);
		1893	if (res)
		1894	goto ERROR6;
		1895	psiconv_debug(config,lev+2,off+len,"First column: %d",
		1896	(*result)->first_unfrozen_column_displayed);
		1897	len += leng;
		1898	} else
		1899	(result)->frozen_rows = (result)->frozen_columns =
		1900	(*result)->first_unfrozen_row_displayed =
		1901	(*result)->first_unfrozen_column_displayed = 0;
		1902
		1903	psiconv_progress(config,lev+2,off+len,
		1904	"Going to read 3 unknown bytes (%02x expected)",0xff);
		1905	for (i = 0; i < 3 ; i++) {
		1906	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		1907	if (res)
		1908	goto ERROR6;
		1909	if (temp != 0xff) {
		1910	psiconv_warn(config,lev+2,off+len,
		1911	"Grid section unknown byte %d has unknown value (ignored)",
		1912	i);
		1913	psiconv_debug(config,lev+2,off+len,"Value: %02x",temp);
		1914	}
		1915	len ++;
		1916	}
		1917
		1918	if (length)
		1919	*length = len;
		1920
		1921	psiconv_progress(config,lev,off+len-1,
		1922	"End of sheet grid section (total length: %08x)", len);
		1923	return 0;
		1924
		1925	ERROR6:
		1926	psiconv_free_sheet_grid_break_list((*result)->column_page_breaks);
		1927	ERROR5:
		1928	psiconv_free_sheet_grid_break_list((*result)->row_page_breaks);
		1929	ERROR4:
		1930	psiconv_free_sheet_grid_size_list((*result)->column_heights);
		1931	ERROR3:
		1932	psiconv_free_sheet_grid_size_list((*result)->row_heights);
		1933	ERROR2:
		1934	free(*result);
		1935	ERROR1:
		1936	psiconv_warn(config,lev+1,off,"Reading of Sheet Grid Section failed");
		1937	if (length)
		1938	*length = 0;
		1939	if (!res)
		1940	return -PSICONV_E_NOMEM;
		1941	else
		1942	return res;
		1943	}
		1944
		1945
		1946	int psiconv_parse_sheet_grid_size_list(const psiconv_config config,
		1947	const psiconv_buffer buf, int lev,
		1948	psiconv_u32 off, int *length,
		1949	psiconv_sheet_grid_size_list *result)
		1950	{
		1951	int res=0;
		1952	int len=0,i;
		1953	int leng,listlen;
		1954	psiconv_sheet_grid_size size;
		1955
		1956	psiconv_progress(config,lev+1,off,"Going to read a sheet grid size list");
		1957	if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_grid_size_s))))
		1958	goto ERROR1;
		1959
		1960	psiconv_progress(config,lev+2,off+len,
		1961	"Going to read the number of elements");
		1962	listlen = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
		1963	if (res)
		1964	goto ERROR2;
		1965	psiconv_debug(config,lev+2,off+len,"Number of elements: %d",listlen);
		1966	len += leng;
		1967
		1968	psiconv_progress(config,lev+2,off+len,"Going to read all elements");
		1969	for (i = 0; i < listlen; i++) {
		1970	psiconv_progress(config,lev+3,off+len,"Going to read element %d",i);
		1971	if ((res = psiconv_parse_sheet_grid_size(config,buf,lev+3,off+len,&leng,&size)))
		1972	goto ERROR2;
		1973	if ((res = psiconv_list_add(*result,size)))
		1974	goto ERROR3;
		1975	free(size);
		1976	len += leng;
		1977	}
		1978
		1979	if (length)
		1980	*length = len;
		1981
		1982	psiconv_progress(config,lev,off+len-1,
		1983	"End of sheet grid size list (total length: %08x)", len);
		1984	return 0;
		1985
		1986	ERROR3:
		1987	psiconv_free_sheet_grid_size(size);
		1988	ERROR2:
		1989	psiconv_list_free(*result);
		1990	ERROR1:
		1991	psiconv_warn(config,lev+1,off,"Reading of Sheet Grid Size List failed");
		1992	if (length)
		1993	*length = 0;
		1994	if (!res)
		1995	return -PSICONV_E_NOMEM;
		1996	else
		1997	return res;
		1998	}
		1999
		2000	int psiconv_parse_sheet_grid_size(const psiconv_config config,
		2001	const psiconv_buffer buf, int lev,
		2002	psiconv_u32 off, int *length,
		2003	psiconv_sheet_grid_size *result)
		2004	{
		2005	int res=0;
		2006	int len=0;
		2007	int leng;
		2008
		2009	psiconv_progress(config,lev+1,off,"Going to read a sheet grid size");
		2010
		2011	if (!(result = malloc(sizeof(*result))))
		2012	goto ERROR1;
		2013
		2014	psiconv_progress(config,lev+2,off+len, "Going to read the row or column number");
		2015	(*result)->line_number = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		2016	if (res)
		2017	goto ERROR2;
		2018	psiconv_debug(config,lev+2,off+len,"Line number: %d\n",(*result)->line_number);
		2019	len += 4;
		2020
		2021	psiconv_progress(config,lev+2,off+len, "Going to read the row or column height");
		2022	(*result)->size = psiconv_read_length(config,buf,lev+2,off+len,&leng,&res);
		2023	if (res)
		2024	goto ERROR2;
		2025	psiconv_debug(config,lev+2,off+len,"Size: %f\n",(*result)->size);
		2026	len += leng;
		2027
		2028	if (length)
		2029	*length = len;
		2030
		2031	psiconv_progress(config,lev,off+len-1,
		2032	"End of sheet grid size(total length: %08x)", len);
		2033	return 0;
		2034
		2035	ERROR2:
		2036	free (*result);
		2037	ERROR1:
		2038	psiconv_warn(config,lev+1,off,"Reading of Sheet Grid Size failed");
		2039	if (length)
		2040	*length = 0;
		2041	if (!res)
		2042	return -PSICONV_E_NOMEM;
		2043	else
		2044	return res;
		2045	}
		2046
		2047
		2048	int psiconv_parse_sheet_grid_break_list(const psiconv_config config,
		2049	const psiconv_buffer buf, int lev,
		2050	psiconv_u32 off, int *length,
		2051	psiconv_sheet_grid_break_list *result)
		2052	{
		2053	int res=0;
		2054	int len=0,i;
		2055	int leng,listlen;
		2056	psiconv_u32 nr;
		2057
		2058	psiconv_progress(config,lev+1,off,"Going to read a sheet grid break list");
		2059	if (!(*result = psiconv_list_new(sizeof(psiconv_u32))))
		2060	goto ERROR1;
		2061
		2062	psiconv_progress(config,lev+2,off+len,
		2063	"Going to read the number of elements");
		2064	listlen = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
		2065	if (res)
		2066	goto ERROR2;
		2067	psiconv_debug(config,lev+2,off+len,"Number of elements: %d",listlen);
		2068	len += leng;
		2069
		2070	psiconv_progress(config,lev+2,off+len,"Going to read all elements");
		2071	for (i = 0; i < listlen; i++) {
		2072	psiconv_progress(config,lev+3,off+len,"Going to read element %d",i);
		2073	nr = psiconv_read_u32(config,buf,lev+3,off+len,&res);
		2074	if (res)
		2075	goto ERROR2;
		2076	if ((res = psiconv_list_add(*result,&nr)))
		2077	goto ERROR2;
		2078	len += leng;
		2079	}
		2080
		2081	if (length)
		2082	*length = len;
		2083
		2084	psiconv_progress(config,lev,off+len-1,
		2085	"End of sheet grid break list (total length: %08x)", len);
		2086	return 0;
		2087
		2088	ERROR2:
		2089	psiconv_list_free(*result);
		2090	ERROR1:
		2091	psiconv_warn(config,lev+1,off,"Reading of Sheet Grid break List failed");
		2092	if (length)
		2093	*length = 0;
		2094	if (!res)
		2095	return -PSICONV_E_NOMEM;
		2096	else
		2097	return res;
		2098	}
		2099

 Legend:



Removed from v.110
 


changed lines


 
Added in v.168
 Legend:



Removed from v.110
 


changed lines


 
Added in v.168
-Removed from v.110
+Added in v.168

frodo@frodo.looijaard.name	ViewVC Help
Powered by ViewVC 1.1.26