/[public]/psiconv/trunk/lib/psiconv/parse_formula.c
ViewVC logotype

Annotation of /psiconv/trunk/lib/psiconv/parse_formula.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 110 - (hide annotations)
Sun Mar 4 22:10:45 2001 UTC (23 years, 1 month ago) by frodo
File MIME type: text/plain
File size: 28623 byte(s) 
(Frodo) Thomas Decsi's major sheet patch
1 frodo 100 /*
2     parse_formula.c - Part of psiconv, a PSION 5 file formats converter
3     Copyright (c) 2001 Frodo Looijaard <frodol@dds.nl>
4    
5     This program is free software; you can redistribute it and/or modify
6     it under the terms of the GNU General Public License as published by
7     the Free Software Foundation; either version 2 of the License, or
8     (at your option) any later version.
9    
10     This program is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13     GNU General Public License for more details.
14    
15     You should have received a copy of the GNU General Public License
16     along with this program; if not, write to the Free Software
17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18     */
19    
20     #include "config.h"
21     #include "compat.h"
22    
23     #include <stdlib.h>
24    
25     #include "parse_routines.h"
26     #include "error.h"
27    
28     struct formula_element
29     {
30     psiconv_formula_type_t formula_type;
31     int number_of_args;
32     const char* name;
33     };
34    
35     static struct formula_element formula_elements[256] =
36     {
37     {psiconv_formula_unknown,0,"*UNKNOWN*"}, /* 0 */
38     {psiconv_formula_op_lt,2,"<"},
39     {psiconv_formula_op_le,2,"<="},
40     {psiconv_formula_op_gt,2,">"},
41     {psiconv_formula_op_ge,2,">="},
42     {psiconv_formula_op_ne,2,"<>"},
43     {psiconv_formula_op_eq,2,"="},
44     {psiconv_formula_op_add,2,"+"},
45     {psiconv_formula_op_sub,2,"-"},
46     {psiconv_formula_op_mul,2,"*"},
47     {psiconv_formula_op_div,2,"/"},
48     {psiconv_formula_op_pow,2,"^"},
49     {psiconv_formula_op_pos,1,"+"},
50     {psiconv_formula_op_neg,1,"-"},
51 frodo 107 {psiconv_formula_op_not,1,"NOT"},
52     {psiconv_formula_op_and,2,"AND"},
53 frodo 108 {psiconv_formula_op_or,2,"OR"}, /* 10 */
54 frodo 100 {psiconv_formula_op_con,2,"&"},
55 frodo 107 {psiconv_formula_op_bra,1,"()"},
56 frodo 100 {psiconv_formula_unknown,0,"*UNKNOWN*"},
57     {psiconv_formula_unknown,0,"*UNKNOWN*"},
58     {psiconv_formula_mark_eof,0,"End of formula"},
59     {psiconv_formula_unknown,0,"*UNKNOWN*"},
60     {psiconv_formula_unknown,0,"*UNKNOWN*"},
61     {psiconv_formula_unknown,0,"*UNKNOWN*"},
62     {psiconv_formula_unknown,0,"*UNKNOWN*"},
63     {psiconv_formula_unknown,0,"*UNKNOWN*"},
64     {psiconv_formula_unknown,0,"*UNKNOWN*"},
65     {psiconv_formula_unknown,0,"*UNKNOWN*"},
66     {psiconv_formula_unknown,0,"*UNKNOWN*"},
67     {psiconv_formula_unknown,0,"*UNKNOWN*"},
68     {psiconv_formula_dat_float,0,"Floating point number"},
69     {psiconv_formula_dat_int,0,"Signed integer number"}, /* 20 */
70     {psiconv_formula_unknown,0,"*UNKNOWN*"},
71     {psiconv_formula_unknown,0,"*UNKNOWN*"},
72     {psiconv_formula_unknown,0,"*UNKNOWN*"},
73     {psiconv_formula_unknown,0,"*UNKNOWN*"},
74     {psiconv_formula_dat_var,0,"Named variable"},
75     {psiconv_formula_dat_string,0,"String"},
76     {psiconv_formula_dat_cellref,0,"Cell reference"},
77     {psiconv_formula_dat_cellblock,0,"Cell block"},
78     {psiconv_formula_dat_vcellblock,0,"Cell block {varargs}"},
79     {psiconv_formula_mark_opsep,0,"Operand separator"},
80     {psiconv_formula_mark_opend,0,"Operand list end"},
81     {psiconv_formula_unknown,0,"*UNKNOWN*"},
82     {psiconv_formula_unknown,0,"*UNKNOWN*"},
83     {psiconv_formula_unknown,0,"*UNKNOWN*"},
84     {psiconv_formula_unknown,0,"*UNKNOWN*"},
85     {psiconv_formula_unknown,0,"*UNKNOWN*"}, /* 30 */
86     {psiconv_formula_unknown,0,"*UNKNOWN*"},
87     {psiconv_formula_unknown,0,"*UNKNOWN*"},
88     {psiconv_formula_fun_false,0,"FALSE"},
89     {psiconv_formula_fun_if,3,"IF"},
90     {psiconv_formula_fun_true,0,"TRUE"},
91     {psiconv_formula_fun_cell,2,"CELL"},
92     {psiconv_formula_fun_errortype,0,"ERRORTYPE"},
93     {psiconv_formula_fun_isblank,1,"ISBLANK"},
94     {psiconv_formula_fun_iserr,1,"ISERR"},
95     {psiconv_formula_fun_iserror,1,"ISERROR"},
96     {psiconv_formula_fun_islogical,1,"ISLOGICAL"},
97     {psiconv_formula_fun_isna,1,"ISNA"},
98     {psiconv_formula_fun_isnontext,1,"ISNONTEXT"},
99     {psiconv_formula_fun_isnumber,1,"ISNUMBER"},
100     {psiconv_formula_fun_istext,1,"ISTEXT"},
101     {psiconv_formula_fun_n,1,"N"}, /* 40 */
102     {psiconv_formula_fun_type,1,"TYPE"},
103     {psiconv_formula_fun_address,2,"ADDRESS"},
104     {psiconv_formula_fun_column,1,"COLUMN"},
105     {psiconv_formula_fun_columns,1,"COLUMNS"},
106     {psiconv_formula_fun_hlookup,3,"HLOOKUP"},
107     {psiconv_formula_fun_index,3,"INDEX"},
108     {psiconv_formula_fun_indirect,1,"INDIRECT"},
109     {psiconv_formula_fun_lookup,3,"LOOKUP"},
110     {psiconv_formula_fun_offset,3,"OFFSET"},
111     {psiconv_formula_fun_row,1,"ROW"},
112     {psiconv_formula_fun_rows,1,"ROWS"},
113     {psiconv_formula_fun_vlookup,3,"VLOOKUP"},
114     {psiconv_formula_fun_char,1,"CHAR"},
115     {psiconv_formula_fun_code,1,"CODE"},
116     {psiconv_formula_fun_exact,2,"EXACT"},
117     {psiconv_formula_fun_find,3,"FIND"}, /* 50 */
118     {psiconv_formula_fun_left,2,"LEFT"},
119     {psiconv_formula_fun_len,1,"LEN"},
120     {psiconv_formula_fun_lower,1,"LOWER"},
121     {psiconv_formula_fun_mid,3,"MID"},
122     {psiconv_formula_fun_proper,1,"PROPER"},
123     {psiconv_formula_fun_replace,4,"REPLACE"},
124     {psiconv_formula_fun_rept,2,"REPT"},
125     {psiconv_formula_fun_right,2,"RIGHT"},
126     {psiconv_formula_fun_string,2,"STRING"},
127     {psiconv_formula_fun_t,1,"T"},
128     {psiconv_formula_fun_trim,1,"TRIM"},
129     {psiconv_formula_fun_upper,1,"UPPER"},
130     {psiconv_formula_fun_value,1,"VALUE"},
131     {psiconv_formula_fun_date,3,"DATE"},
132     {psiconv_formula_fun_datevalue,1,"DATEVALUE"},
133     {psiconv_formula_fun_day,1,"DAY"}, /* 60 */
134     {psiconv_formula_fun_hour,1,"HOUR"},
135     {psiconv_formula_fun_minute,1,"MINUTE"},
136     {psiconv_formula_fun_month,1,"MONTH"},
137     {psiconv_formula_fun_now,0,"NOW"},
138     {psiconv_formula_fun_second,1,"SECOND"},
139     {psiconv_formula_fun_today,0,"TODAY"},
140     {psiconv_formula_fun_time,3,"TIME"},
141     {psiconv_formula_fun_timevalue,1,"TIMEVALUE"},
142     {psiconv_formula_fun_year,1,"YEAR"},
143     {psiconv_formula_fun_abs,1,"ABS"},
144     {psiconv_formula_fun_acos,1,"ACOS"},
145     {psiconv_formula_fun_asin,1,"ASIN"},
146     {psiconv_formula_fun_atan,1,"ATAN"},
147     {psiconv_formula_fun_atan2,2,"ATAN2"},
148     {psiconv_formula_fun_cos,1,"COS"},
149     {psiconv_formula_fun_degrees,0,"DEGREES"}, /* 70 */
150     {psiconv_formula_fun_exp,1,"EXP"},
151     {psiconv_formula_fun_fact,1,"FACT"},
152     {psiconv_formula_fun_int,1,"INT"},
153     {psiconv_formula_fun_ln,1,"LN"},
154     {psiconv_formula_fun_log10,1,"LOG10"},
155     {psiconv_formula_fun_mod,2,"MOD"},
156     {psiconv_formula_fun_pi,0,"PI"},
157     {psiconv_formula_fun_radians,1,"RADIANS"},
158     {psiconv_formula_fun_rand,0,"RAND"},
159     {psiconv_formula_fun_round,2,"ROUND"},
160     {psiconv_formula_fun_sign,1,"SIGN"},
161     {psiconv_formula_fun_sin,1,"SIN"},
162     {psiconv_formula_fun_sqrt,1,"SQRT"},
163     {psiconv_formula_fun_sumproduct,2,"SUMPRODUCT"},
164     {psiconv_formula_fun_tan,1,"TAN"},
165     {psiconv_formula_fun_trunc,1,"TRUNC"}, /* 80 */
166     {psiconv_formula_fun_cterm,3,"CTERM"},
167     {psiconv_formula_fun_ddb,4,"DDB"},
168     {psiconv_formula_fun_fv,3,"FV"},
169     {psiconv_formula_fun_irr,2,"IRR"},
170     {psiconv_formula_fun_npv,2,"NPV"},
171     {psiconv_formula_fun_pmt,3,"PMT"},
172     {psiconv_formula_fun_pv,3,"PV"},
173     {psiconv_formula_fun_rate,3,"RATE"},
174     {psiconv_formula_fun_sln,3,"SLN"},
175     {psiconv_formula_fun_syd,4,"SYD"},
176     {psiconv_formula_fun_term,3,"TERM"},
177     {psiconv_formula_fun_combin,2,"COMBIN"},
178     {psiconv_formula_fun_permut,2,"PERMUT"},
179     {psiconv_formula_vfn_average,-1,"AVERAGE"},
180     {psiconv_formula_vfn_choose,-1,"CHOOSE"},
181     {psiconv_formula_vfn_count,-1,"COUNT"}, /* 90 */
182     {psiconv_formula_vfn_counta,-1,"COUNTA"},
183     {psiconv_formula_vfn_countblank,-1,"COUNTBLANK"},
184     {psiconv_formula_vfn_max,-1,"MAX"},
185     {psiconv_formula_vfn_min,-1,"MIN"},
186     {psiconv_formula_vfn_product,-1,"PRODUCT"},
187     {psiconv_formula_vfn_stdevp,-1,"STDEVP"},
188     {psiconv_formula_vfn_stdev,-1,"STDEV"},
189     {psiconv_formula_vfn_sum,-1,"SUM"},
190     {psiconv_formula_vfn_sumsq,-1,"SUMSQ"},
191     {psiconv_formula_vfn_varp,-1,"VARP"},
192     {psiconv_formula_vfn_var,-1,"VAR"},
193     {psiconv_formula_unknown,0,"*UNKNOWN*"},
194     {psiconv_formula_unknown,0,"*UNKNOWN*"},
195     {psiconv_formula_unknown,0,"*UNKNOWN*"},
196     {psiconv_formula_unknown,0,"*UNKNOWN*"},
197     {psiconv_formula_unknown,0,"*UNKNOWN*"}, /* A0 */
198     {psiconv_formula_unknown,0,"*UNKNOWN*"},
199     {psiconv_formula_unknown,0,"*UNKNOWN*"},
200     {psiconv_formula_unknown,0,"*UNKNOWN*"},
201     {psiconv_formula_unknown,0,"*UNKNOWN*"},
202     {psiconv_formula_unknown,0,"*UNKNOWN*"},
203     {psiconv_formula_unknown,0,"*UNKNOWN*"},
204     {psiconv_formula_unknown,0,"*UNKNOWN*"},
205     {psiconv_formula_unknown,0,"*UNKNOWN*"},
206     {psiconv_formula_unknown,0,"*UNKNOWN*"},
207     {psiconv_formula_unknown,0,"*UNKNOWN*"},
208     {psiconv_formula_unknown,0,"*UNKNOWN*"},
209     {psiconv_formula_unknown,0,"*UNKNOWN*"},
210     {psiconv_formula_unknown,0,"*UNKNOWN*"},
211     {psiconv_formula_unknown,0,"*UNKNOWN*"},
212     {psiconv_formula_unknown,0,"*UNKNOWN*"},
213     {psiconv_formula_unknown,0,"*UNKNOWN*"}, /* B0 */
214     {psiconv_formula_unknown,0,"*UNKNOWN*"},
215     {psiconv_formula_unknown,0,"*UNKNOWN*"},
216     {psiconv_formula_unknown,0,"*UNKNOWN*"},
217     {psiconv_formula_unknown,0,"*UNKNOWN*"},
218     {psiconv_formula_unknown,0,"*UNKNOWN*"},
219     {psiconv_formula_unknown,0,"*UNKNOWN*"},
220     {psiconv_formula_unknown,0,"*UNKNOWN*"},
221     {psiconv_formula_unknown,0,"*UNKNOWN*"},
222     {psiconv_formula_unknown,0,"*UNKNOWN*"},
223     {psiconv_formula_unknown,0,"*UNKNOWN*"},
224     {psiconv_formula_unknown,0,"*UNKNOWN*"},
225     {psiconv_formula_unknown,0,"*UNKNOWN*"},
226     {psiconv_formula_unknown,0,"*UNKNOWN*"},
227     {psiconv_formula_unknown,0,"*UNKNOWN*"},
228     {psiconv_formula_unknown,0,"*UNKNOWN*"},
229     {psiconv_formula_unknown,0,"*UNKNOWN*"}, /* C0 */
230     {psiconv_formula_unknown,0,"*UNKNOWN*"},
231     {psiconv_formula_unknown,0,"*UNKNOWN*"},
232     {psiconv_formula_unknown,0,"*UNKNOWN*"},
233     {psiconv_formula_unknown,0,"*UNKNOWN*"},
234     {psiconv_formula_unknown,0,"*UNKNOWN*"},
235     {psiconv_formula_unknown,0,"*UNKNOWN*"},
236     {psiconv_formula_unknown,0,"*UNKNOWN*"},
237     {psiconv_formula_unknown,0,"*UNKNOWN*"},
238     {psiconv_formula_unknown,0,"*UNKNOWN*"},
239     {psiconv_formula_unknown,0,"*UNKNOWN*"},
240     {psiconv_formula_unknown,0,"*UNKNOWN*"},
241     {psiconv_formula_unknown,0,"*UNKNOWN*"},
242     {psiconv_formula_unknown,0,"*UNKNOWN*"},
243     {psiconv_formula_unknown,0,"*UNKNOWN*"},
244     {psiconv_formula_unknown,0,"*UNKNOWN*"},
245     {psiconv_formula_unknown,0,"*UNKNOWN*"}, /* D0 */
246     {psiconv_formula_unknown,0,"*UNKNOWN*"},
247     {psiconv_formula_unknown,0,"*UNKNOWN*"},
248     {psiconv_formula_unknown,0,"*UNKNOWN*"},
249     {psiconv_formula_unknown,0,"*UNKNOWN*"},
250     {psiconv_formula_unknown,0,"*UNKNOWN*"},
251     {psiconv_formula_unknown,0,"*UNKNOWN*"},
252     {psiconv_formula_unknown,0,"*UNKNOWN*"},
253     {psiconv_formula_unknown,0,"*UNKNOWN*"},
254     {psiconv_formula_unknown,0,"*UNKNOWN*"},
255     {psiconv_formula_unknown,0,"*UNKNOWN*"},
256     {psiconv_formula_unknown,0,"*UNKNOWN*"},
257     {psiconv_formula_unknown,0,"*UNKNOWN*"},
258     {psiconv_formula_unknown,0,"*UNKNOWN*"},
259     {psiconv_formula_unknown,0,"*UNKNOWN*"},
260     {psiconv_formula_unknown,0,"*UNKNOWN*"},
261     {psiconv_formula_unknown,0,"*UNKNOWN*"}, /* E0 */
262     {psiconv_formula_unknown,0,"*UNKNOWN*"},
263     {psiconv_formula_unknown,0,"*UNKNOWN*"},
264     {psiconv_formula_unknown,0,"*UNKNOWN*"},
265     {psiconv_formula_unknown,0,"*UNKNOWN*"},
266     {psiconv_formula_unknown,0,"*UNKNOWN*"},
267     {psiconv_formula_unknown,0,"*UNKNOWN*"},
268     {psiconv_formula_unknown,0,"*UNKNOWN*"},
269     {psiconv_formula_unknown,0,"*UNKNOWN*"},
270     {psiconv_formula_unknown,0,"*UNKNOWN*"},
271     {psiconv_formula_unknown,0,"*UNKNOWN*"},
272     {psiconv_formula_unknown,0,"*UNKNOWN*"},
273     {psiconv_formula_unknown,0,"*UNKNOWN*"},
274     {psiconv_formula_unknown,0,"*UNKNOWN*"},
275     {psiconv_formula_unknown,0,"*UNKNOWN*"},
276     {psiconv_formula_unknown,0,"*UNKNOWN*"},
277     {psiconv_formula_unknown,0,"*UNKNOWN*"}, /* F0 */
278     {psiconv_formula_unknown,0,"*UNKNOWN*"},
279     {psiconv_formula_unknown,0,"*UNKNOWN*"},
280     {psiconv_formula_unknown,0,"*UNKNOWN*"},
281     {psiconv_formula_unknown,0,"*UNKNOWN*"},
282     {psiconv_formula_unknown,0,"*UNKNOWN*"},
283     {psiconv_formula_unknown,0,"*UNKNOWN*"},
284     {psiconv_formula_unknown,0,"*UNKNOWN*"},
285     {psiconv_formula_unknown,0,"*UNKNOWN*"},
286     {psiconv_formula_unknown,0,"*UNKNOWN*"},
287     {psiconv_formula_unknown,0,"*UNKNOWN*"},
288     {psiconv_formula_unknown,0,"*UNKNOWN*"},
289     {psiconv_formula_unknown,0,"*UNKNOWN*"}};
290    
291 frodo 102 static int psiconv_parse_sheet_ref(const psiconv_buffer buf,int lev,
292     psiconv_u32 off, int *length,
293     psiconv_sheet_ref_t *result)
294     {
295     int res;
296     psiconv_u16 temp;
297    
298     psiconv_progress(lev+1,off,"Going to read a sheet ref");
299     psiconv_progress(lev+2,off,"Going to read the offset encoding");
300     temp = psiconv_read_u16(buf,lev+2,off,&res);
301     if (res) {
302     if (length)
303     *length = 0;
304     return res;
305     }
306     psiconv_debug(lev+2,off,"Encoded word: %04x",temp);
307     result->absolute = (temp & 0x4000)?psiconv_bool_true:psiconv_bool_false;
308     result->offset = (temp & 0x3fff) * ((temp & 0x8000)?-1:1);
309     psiconv_debug(lev+2,off,"Reference: %s offset %d",
310     result->absolute?"absolute":"relative",result->offset);
311     if (length)
312     *length = 2;
313     return 0;
314     }
315    
316     static int psiconv_parse_sheet_cell_reference(const psiconv_buffer buf,int lev,
317     psiconv_u32 off, int *length,
318     psiconv_sheet_cell_reference_t *result)
319     {
320     int len = 0;
321     int leng,res;
322     psiconv_u8 temp;
323    
324     psiconv_progress(lev+1,off+len,"Going to read a sheet cell reference");
325     psiconv_progress(lev+2,off+len,"Going to read the row reference");
326     if ((res = psiconv_parse_sheet_ref(buf,lev+2,off+len,&leng,&result->row)))
327     goto ERROR;
328     len += leng;
329     psiconv_progress(lev+2,off+len,"Going to read the column reference");
330     if ((res = psiconv_parse_sheet_ref(buf,lev+2,off+len,&leng,&result->column)))
331     goto ERROR;
332     len += leng;
333    
334     psiconv_progress(lev+2,off+len,
335     "Going to read the trailing byte (%02x expected)",0);
336     temp = psiconv_read_u8(buf,lev+2,off+len,&res);
337     if (res)
338     goto ERROR;
339     if (temp != 0) {
340     psiconv_warn(lev+2,off+len,"Unknown byte in cell reference (ignored");
341     psiconv_debug(lev+2,off+len,"Trailing byte: %02x",temp);
342     }
343     len ++;
344     psiconv_progress(lev,off+len-1,
345     "End of cell reference (total length: %08x)", len);
346     if (length)
347     *length = len;
348     return 0;
349     ERROR:
350     if (length)
351     *length = 0;
352     return res;
353     }
354    
355     static int psiconv_parse_sheet_cell_block(const psiconv_buffer buf,int lev,
356     psiconv_u32 off, int *length,
357     psiconv_sheet_cell_block_t *result)
358     {
359     int len = 0;
360     int leng,res;
361    
362     psiconv_progress(lev+1,off+len,"Going to read a sheet cell block");
363     psiconv_progress(lev+2,off+len,"Going to read the first cell");
364     if ((res = psiconv_parse_sheet_cell_reference(buf,lev+2,off+len,&leng,
365     &result->first)))
366     goto ERROR;
367     len += leng;
368     psiconv_progress(lev+2,off+len,"Going to read the last cell");
369     if ((res = psiconv_parse_sheet_cell_reference(buf,lev+2,off+len,&leng,
370     &result->last)))
371     goto ERROR;
372     len += leng;
373     psiconv_progress(lev,off+len-1,
374     "End of cell block (total length: %08x)", len);
375     if (length)
376     *length = len;
377     return 0;
378     ERROR:
379     if (length)
380     *length = 0;
381     return res;
382     }
383    
384 frodo 105 static int psiconv_parse_formula_element_list(const psiconv_buffer buf, int lev,
385     psiconv_u32 off, int *length,
386     psiconv_formula *result,
387     psiconv_u32 maxlen)
388 frodo 100 {
389     int res=0;
390     int len=0;
391     int leng;
392     int eof = 0;
393 frodo 106 psiconv_u8 marker,submarker;
394 frodo 100 psiconv_formula_list formula_stack;
395 frodo 106 psiconv_formula formula,subformula,subformula1,subformula2,
396     subformula3,subformula4;
397     psiconv_u16 temp,nr_of_subs;
398 frodo 100
399 frodo 105 psiconv_progress(lev+1,off,"Going to read a formula element list");
400 frodo 100 if (!(*result = malloc(sizeof(**result))))
401     goto ERROR1;
402     if (!(formula_stack = psiconv_list_new(sizeof(struct psiconv_formula_s))))
403     goto ERROR2;
404     if (!(formula = malloc(sizeof(*formula))))
405     goto ERROR3;
406     /* By setting the type to unknown, we can safely call psiconv_free_formula */
407     formula->type = psiconv_formula_unknown;
408     if (!(subformula1 = malloc(sizeof(*subformula1))))
409     goto ERROR4;
410     subformula1->type = psiconv_formula_unknown;
411     if (!(subformula2 = malloc(sizeof(*subformula2))))
412     goto ERROR5;
413     subformula2->type = psiconv_formula_unknown;
414     if (!(subformula3 = malloc(sizeof(*subformula3))))
415     goto ERROR6;
416     subformula3->type = psiconv_formula_unknown;
417     if (!(subformula4 = malloc(sizeof(*subformula4))))
418     goto ERROR7;
419     subformula4->type = psiconv_formula_unknown;
420    
421 frodo 105 while (!eof && len+off < maxlen) {
422 frodo 100 psiconv_progress(lev+3,off+len,"Going to read a formula item marker");
423     marker = psiconv_read_u8(buf,lev+2,off+len,&res);
424     if (res)
425     goto ERROR8;
426     psiconv_debug(lev+3,off+len,"Marker: %02x (%s)",marker,
427     formula_elements[marker].name);
428     len ++;
429    
430     if (formula_elements[marker].formula_type == psiconv_formula_unknown) {
431     psiconv_warn(lev+3,off+len,"Unknown formula marker found!");
432     goto ERROR8;
433 frodo 105 } else if ((formula_elements[marker].formula_type ==
434     psiconv_formula_mark_eof) ||
435     (formula_elements[marker].formula_type ==
436     psiconv_formula_mark_opend) ||
437     (formula_elements[marker].formula_type ==
438     psiconv_formula_mark_opsep)) {
439     len--;
440     psiconv_progress(lev+3,off+len,"End of this formula list");
441 frodo 100 eof = 1;
442     } else if (formula_elements[marker].formula_type ==
443     psiconv_formula_dat_int) {
444     psiconv_progress(lev+3,off+len,"Next item: an integer");
445     formula->data.dat_int = psiconv_read_u32(buf,lev+2,off+len,&res);
446     if (res)
447     goto ERROR8;
448     formula->type = formula_elements[marker].formula_type;
449     psiconv_debug(lev+3,off+len,"Value: %08x",formula->data.dat_int);
450     len += 4;
451     if ((res = psiconv_list_add(formula_stack,formula)))
452     goto ERROR8;
453     formula->type = psiconv_formula_unknown;
454 frodo 101 } else if (formula_elements[marker].formula_type ==
455     psiconv_formula_dat_float) {
456     psiconv_progress(lev+3,off+len,"Next item: a float");
457     formula->data.dat_float = psiconv_read_float(buf,lev+2,off+len,&leng,
458     &res);
459     if (res)
460     goto ERROR8;
461     formula->type = formula_elements[marker].formula_type;
462     psiconv_debug(lev+3,off+len,"Value: %f",formula->data.dat_float);
463     len += leng;
464     if ((res = psiconv_list_add(formula_stack,formula)))
465     goto ERROR8;
466     formula->type = psiconv_formula_unknown;
467 frodo 102 } else if (formula_elements[marker].formula_type ==
468     psiconv_formula_dat_cellref) {
469     psiconv_progress(lev+3,off+len,"Next item: a cell reference");
470     if ((res = psiconv_parse_sheet_cell_reference(buf,lev+2,off+len,&leng,
471     &formula->data.dat_cellref)))
472     goto ERROR8;
473     formula->type = formula_elements[marker].formula_type;
474     len += leng;
475     if ((res = psiconv_list_add(formula_stack,formula)))
476     goto ERROR8;
477     formula->type = psiconv_formula_unknown;
478 frodo 106 } else if ((formula_elements[marker].formula_type ==
479     psiconv_formula_dat_cellblock) ||
480     (formula_elements[marker].formula_type ==
481     psiconv_formula_dat_vcellblock)) {
482 frodo 102 psiconv_progress(lev+3,off+len,"Next item: a cell block");
483     if ((res = psiconv_parse_sheet_cell_block(buf,lev+2,off+len,&leng,
484     &formula->data.dat_cellblock)))
485     goto ERROR8;
486     formula->type = formula_elements[marker].formula_type;
487     len += leng;
488     if ((res = psiconv_list_add(formula_stack,formula)))
489     goto ERROR8;
490     formula->type = psiconv_formula_unknown;
491 frodo 103 } else if (formula_elements[marker].formula_type ==
492     psiconv_formula_dat_string) {
493     psiconv_progress(lev+3,off+len,"Next item: a string");
494     formula->data.dat_string =
495 frodo 110 psiconv_read_short_string(buf,lev+2,off+len,&leng,&res);
496 frodo 103 if (res)
497     goto ERROR8;
498     formula->type = formula_elements[marker].formula_type;
499     len += leng;
500     if ((res = psiconv_list_add(formula_stack,formula)))
501     goto ERROR8;
502     formula->type = psiconv_formula_unknown;
503 frodo 100 } else if ((formula_elements[marker].formula_type ==
504 frodo 101 psiconv_formula_dat_var) ||
505 frodo 100 (formula_elements[marker].formula_type ==
506 frodo 105 psiconv_formula_dat_vcellblock)) {
507 frodo 100 psiconv_warn(lev+3,off+len,"Not yet supported formula mark!");
508     goto ERROR8;
509     } else if (formula_elements[marker].number_of_args == -1) {
510 frodo 106 psiconv_progress(lev+3,off+len,"Going to parse a vararg function");
511     if (!(formula->data.fun_operands =
512     psiconv_list_new(sizeof(*formula))))
513     goto ERROR8;
514     formula->type = formula_elements[marker].formula_type;
515     nr_of_subs = 0;
516     do {
517     nr_of_subs ++;
518     psiconv_progress(lev+4,off+len,"Going to read vararg argument %d",
519     nr_of_subs);
520     if ((res = psiconv_parse_formula_element_list(buf,lev+4,off+len,&leng,
521     &subformula,maxlen)))
522     goto ERROR8;
523     len += leng;
524     if ((res = psiconv_list_add(formula->data.fun_operands,subformula))) {
525     psiconv_free_formula(subformula);
526     goto ERROR8;
527     }
528     free(subformula);
529     psiconv_progress(lev+4,off+len,"Going to read the next marker");
530     submarker = psiconv_read_u8(buf,lev+4,off+len,&res);
531     len ++;
532     if (res)
533     goto ERROR8;
534     } while (formula_elements[submarker].formula_type
535     == psiconv_formula_mark_opsep);
536     if (formula_elements[submarker].formula_type
537     != psiconv_formula_mark_opend) {
538     psiconv_warn(lev+3,off+len,"Formula corrupted!");
539     psiconv_debug(lev+3,off+len,"Found unexpected marker %02x",submarker);
540     goto ERROR8;
541     }
542     psiconv_progress(lev+3,off+len,"Going to read the repeated marker %02x",
543     marker);
544     submarker = psiconv_read_u8(buf,lev+3,off+len,&res);
545     if (res)
546     goto ERROR8;
547     if (submarker != marker) {
548     psiconv_warn(lev+3,off+len,"Formula corrupted!");
549     psiconv_debug(lev+3,off+len,"Expected marker %02x, found %02x",
550     marker,submarker);
551     goto ERROR8;
552     }
553     len++;
554     psiconv_progress(lev+3,off+len,
555     "Going to read the number of arguments (%d expected)",
556     nr_of_subs);
557     temp = psiconv_read_u16(buf,lev+3,off+len,&res);
558     if (res)
559     goto ERROR8;
560     if (temp != nr_of_subs) {
561     psiconv_warn(lev+3,off+len,"Formula corrupted!");
562     psiconv_debug(lev+3,off+len,
563     "Read %d arguments, but formula says there are %d",
564     nr_of_subs,temp);
565     goto ERROR8;
566     }
567     len += 2;
568     if ((res = psiconv_list_add(formula_stack,formula)))
569     goto ERROR8;
570     formula->type = psiconv_formula_unknown;
571 frodo 100 } else {
572     if (formula_elements[marker].number_of_args > 0)
573     if ((res = psiconv_list_pop(formula_stack,subformula1)))
574     goto ERROR8;
575     if (formula_elements[marker].number_of_args > 1)
576     if ((res = psiconv_list_pop(formula_stack,subformula2)))
577     goto ERROR8;
578     if (formula_elements[marker].number_of_args > 2)
579     if ((res = psiconv_list_pop(formula_stack,subformula3)))
580     goto ERROR8;
581     if (formula_elements[marker].number_of_args > 3)
582     if ((res = psiconv_list_pop(formula_stack,subformula4)))
583     goto ERROR8;
584     if (!(formula->data.fun_operands =
585     psiconv_list_new(sizeof(*formula))))
586     goto ERROR8;
587     formula->type = formula_elements[marker].formula_type;
588     if (formula_elements[marker].number_of_args > 3)
589     if ((res = psiconv_list_add(formula->data.fun_operands,subformula4)))
590     goto ERROR8;
591     if (formula_elements[marker].number_of_args > 2)
592     if ((res = psiconv_list_add(formula->data.fun_operands,subformula3)))
593     goto ERROR8;
594     if (formula_elements[marker].number_of_args > 1)
595     if ((res = psiconv_list_add(formula->data.fun_operands,subformula2)))
596     goto ERROR8;
597     if (formula_elements[marker].number_of_args > 0)
598     if ((res = psiconv_list_add(formula->data.fun_operands,subformula1)))
599     goto ERROR8;
600     if ((res = psiconv_list_add(formula_stack,formula)))
601     goto ERROR8;
602     subformula4->type = subformula3->type = subformula2->type =
603     subformula1->type = formula->type = psiconv_formula_unknown;
604     }
605     }
606 frodo 105 if ((len+off > maxlen) || !eof) {
607 frodo 100 psiconv_warn(lev+2,off+len,"Formula corrupted!");
608     psiconv_debug(lev+2,off+len,"Expected end: %04x, found end: %04x",
609 frodo 105 maxlen,len+off);
610 frodo 100 goto ERROR8;
611     }
612     if ((psiconv_list_length(formula_stack)) != 1) {
613     psiconv_warn(lev+2,off+len,"Formula corrupted!");
614     psiconv_debug(lev+2,off+len,"More than one item left on the stack (%d)",
615     psiconv_list_length(formula_stack));
616     goto ERROR8;
617     }
618     if ((res = psiconv_list_pop(formula_stack,*result)))
619     goto ERROR8;
620     psiconv_list_free(formula_stack);
621     free(formula);
622    
623     if (length)
624     *length = len;
625    
626     psiconv_progress(lev,off+len-1,
627 frodo 105 "End of formula element list (total length: %08x)", len);
628 frodo 100 return 0;
629    
630     ERROR8:
631     psiconv_free_formula(subformula4);
632     ERROR7:
633     psiconv_free_formula(subformula3);
634     ERROR6:
635     psiconv_free_formula(subformula2);
636     ERROR5:
637     psiconv_free_formula(subformula1);
638     ERROR4:
639     psiconv_free_formula(formula);
640     ERROR3:
641     psiconv_free_formula_list(formula_stack);
642     ERROR2:
643     free (*result);
644     ERROR1:
645 frodo 105 psiconv_warn(lev+1,off,"Reading of formula element list failed");
646     if (length)
647     *length = 0;
648     if (!res)
649     return -PSICONV_E_NOMEM;
650     else
651     return res;
652     }
653    
654    
655    
656    
657     int psiconv_parse_formula(const psiconv_buffer buf, int lev,
658     psiconv_u32 off, int *length,
659     psiconv_formula *result)
660     {
661     int res=0;
662     int len=0;
663     int leng;
664     psiconv_u32 bytelen,formula_end;
665     psiconv_u8 temp;
666    
667     psiconv_progress(lev+1,off,"Going to read a formula");
668    
669     psiconv_progress(lev+2,off+len,
670     "Going to read the formula byte length");
671     bytelen = psiconv_read_S(buf,lev+2,off+len,&leng,&res);
672     if (res)
673     goto ERROR1;
674     psiconv_debug(lev+2,off+len,"Formula byte length: %d",bytelen);
675     len += leng;
676     bytelen += len;
677     formula_end = off + bytelen;
678    
679     psiconv_progress(lev+2,off+len,"Going to read the formula elements list");
680     if ((res = psiconv_parse_formula_element_list(buf,lev+2,off+len,&leng,
681     result,formula_end)))
682     goto ERROR1;
683     len += leng;
684    
685     psiconv_progress(lev+2,off+len,"Going to read the eof marker");
686     temp = psiconv_read_u8(buf,lev+2,off+len,&res);
687     if (res)
688     goto ERROR2;
689     if (formula_elements[temp].formula_type != psiconv_formula_mark_eof) {
690     psiconv_warn(lev+2,off+len,"Formula corrupted!");
691     psiconv_debug(lev+2,off+len,"Expected marker: %02x, found byte: %02x",
692     0x15,temp);
693     goto ERROR2;
694     }
695     len ++;
696    
697     if (off+len != formula_end) {
698     psiconv_warn(lev+2,off+len,"Formula corrupted!");
699     psiconv_debug(lev+2,off+len,"Expected end: %04x, found end: %04x",
700     formula_end,len+off);
701     goto ERROR2;
702     }
703    
704     if (length)
705     *length = len;
706    
707     psiconv_progress(lev,off+len-1,
708     "End of formula (total length: %08x)", len);
709     return 0;
710    
711     ERROR2:
712     psiconv_free_formula(*result);
713     ERROR1:
714 frodo 100 psiconv_warn(lev+1,off,"Reading of formula failed");
715     if (length)
716     *length = 0;
717     if (!res)
718     return -PSICONV_E_NOMEM;
719     else
720     return res;
721     }
722    
723 frodo 105
frodo@frodo.looijaard.name
 ViewVC Help
Powered by ViewVC 1.1.26