xlhtml.c~

excel to html

				if (len > (last-3))
					len = (U16)(last-3);
				if (file_version == EXCEL97)
				{
					/* Check for unicode. Terminate the buffer at 2x len
						since unicode is 2bytes per char. Then see if
						strlen is short...upperbyte is usually 0 in
						western chararcter sets. */
					int t = len << 1;
					if ((t+3) < WBUFF_SIZE)
						working_buffer[t+3] = 0;
					else
						working_buffer[len+3] = 0;
					if ((len+3) < last)
					{
						uni = 2;
						len = (U16)t;
					}
					str = &working_buffer[3];
				}
				else if (file_version == EXCEL95)
				{
					str = &working_buffer[2];
					working_buffer[len+2] = 0;
				}
				else
				{
					if (OutputXML)
						str = (U8*)"<NotImplemented/>String Formula";
					else
						str = (U8*)"***String Formula";
					len = (U16)strlen((char*)str);
					NotImplemented++;
				}
				add_wb_array(str_formula_row, str_formula_col, str_formula_format, opcode, uni, str, len, 0, 0);
			}
			break;
		case 0x5C:	/* Author's name A.K.A. WRITEACCESS */
			working_buffer[bufidx++] = data;
			if ((bufidx == last)&&(author.str == 0))
			{
				if (file_version == EXCEL97)
				{
					author.len = getShort(&working_buffer[0]);
					if ((int)working_buffer[2] & 0x01)
					{
						author.len *= (U16)2;
						author.uni = 2;
					}
					else
						author.uni = 0;
					if (author.len > (last-2))
						author.len = (U16)(last-2);
					author.str = (U8 *)malloc(author.len+1);
					if (author.str)
					{
						memcpy(author.str, &working_buffer[3], author.len);
						author.str[author.len] = 0;
					}
				}
				else if (file_version == EXCEL95)
				{
					author.len = working_buffer[0];
					author.str = (U8 *)malloc(author.len+1);
					if (author.str)
					{
						memcpy(author.str, &working_buffer[1], author.len);
						author.str[author.len] = 0;
					}
					author.uni = 0;
				}
			}
			break;
		case 0x08:	/* Row Data */
			/* There's actually some other interesting things
			   here that we're not collecting. For now, we'll
			   Just get the dimensions of the sheet. */
			working_buffer[bufidx++] = data;
			if (bufidx == last)
			{
				/* question...what is the actual limit?
					This can go as high as 64K. Is this really OK? */
				U16 i, r, fc, lc, d, xf;
				r = getShort(&working_buffer[0]);
				fc = getShort(&working_buffer[2]);
				lc = (U16)(getShort(&working_buffer[4]) - (U16)1);
				d = getShort(&working_buffer[12]);
				xf = getShort(&working_buffer[14]);

				if (ws_array[sheet_count] == 0)
					if (ws_init(sheet_count))
						return;

				if (r > ws_array[sheet_count]->biggest_row)
				{
					if (r < ws_array[sheet_count]->max_rows)
						ws_array[sheet_count]->biggest_row = r;
					else
					{	/* Resize the array... */
						if (MaxRowExceeded == 0)
						{
							int diff = (r/ROWS_INCR) + 1;
							if(resize_c_array(ws_array[sheet_count], ROWS_INCR*diff, 0))
							{
								ws_array[sheet_count]->biggest_row = ws_array[sheet_count]->max_rows - 1;
								MaxRowExceeded = 1;
								return;
							}
							else
								ws_array[sheet_count]->biggest_row = r;
						}
						else
							return;
					}
				}

				if (lc > ws_array[sheet_count]->biggest_col)
				{
					if (lc < ws_array[sheet_count]->max_cols)
						ws_array[sheet_count]->biggest_col = lc;
					else
					{	/* Resize array... */
						if (MaxColExceeded == 0)
						{
							int diff = (lc/COLS_INCR) + 1;
							if (resize_c_array(ws_array[sheet_count], 0, (U16)(COLS_INCR*diff)))
							{
								ws_array[sheet_count]->biggest_col = (S16)(ws_array[sheet_count]->max_cols - 1);
								MaxColExceeded = 1;
								lc = ws_array[sheet_count]->max_cols;
							}
							else
								ws_array[sheet_count]->biggest_col = lc;
						}
						else
							lc = ws_array[sheet_count]->max_cols;
					}
				}
				if ((fc < ws_array[sheet_count]->max_cols)&&(d & 0x0080))	/* fGhostDirty flag */
				{
					for (i=fc; i<lc; i++)
					{	/* Set the default attr... */
						update_cell_xf(r, i, xf);
					}
				}
			}
			break;
		case 0x22:	/* 1904 Flag - MacIntosh Dates or PC Dates */
			working_buffer[bufidx++] = data;
			if (bufidx == 2)
				DatesR1904 = getShort(&working_buffer[0]);
			break;
		case 0x085:	/* BoundSheet */
			working_buffer[bufidx++] = data;
			if (bufidx == last)
			{	/* This is based on Office 97 info... */
				if ((working_buffer[4] & 0x0F) == 0)
				{	/* Worksheet as opposed to chart, etc */
					U16 len;
					U8 uni=0;
					if (file_version == EXCEL97)
					{
						len = (U16)working_buffer[6];		/* FIXME: Check this !!! Was GetShort */
						if (working_buffer[7] & 0x01)
						{
							uni = 2;
							len = (U16)(len<<1);
						}
						if (len != 0)
						{
							working_buffer[8 + len + 1] = 0;
							add_ws_title(uni, &working_buffer[8], len);
						}
					}
					else
					{
						len = working_buffer[6];
						if (len != 0)
						{
							working_buffer[7 + len + 1] = 0;
							add_ws_title(uni, &working_buffer[7], len);
						}
					}
				}
			}
			break;
		case 0x7E:	/* RK Number */
			working_buffer[bufidx++] = data;
			if (bufidx == last)
			{	/* This is based on Office 97 info... */
				U16 r, c, f;
				U32 t;
				S32 n, n2;		/* Must be signed long !!! */
				F64 d;
				char temp[64];

				r = getShort(&working_buffer[0]);
				c = getShort(&working_buffer[2]);
				f = getShort(&working_buffer[4]);
				n = getLong(&working_buffer[6]);
				t = n & 0x03;
				n2 = n>>2;
				switch (t)
				{
					case 0:
						RKtoDouble(n2, &d);
						sprintf(temp, "%.15g", d);
						break;
					case 1:
						RKtoDouble(n2, &d);
						sprintf(temp, "%.15g", d / 100.0);
						break;
					case 2:
						sprintf(temp, "%ld", (S32)n2);
						break;
					default:
						d = (F64) n2;
						sprintf(temp, "%.15g", d / 100.0 );
						break;
				}
				add_wb_array(r, c, f, opcode, (U16)0, (U8 *)temp, (U16)strlen(temp), 0, 0);
			}
			break;
		case 0xBC:		/* Shared Formula's */
/*			working_buffer[bufidx++] = data;
			if (bufidx == last)
			{
				int fr, lr, fc, lc, i, j;
				fr = getShort(&working_buffer[0]);
				lr = getShort(&working_buffer[2]);
				fc = working_buffer[4];
				lc = working_buffer[5];
				for (i=fr; i<=lr; i++)
				{
					for (j=fc; j<=lc; j++)
						add_wb_array(i, j, (U16)0, opcode, 0, "***SHRFORMULA", 13);
				}
				NotImplemented = 1;
			}	*/
			break;
		case 0x21:		/* Arrays */
			working_buffer[bufidx++] = data;
			if (bufidx == last)
			{
				U16 fr, lr, fc, lc, i, j;
				fr = getShort(&working_buffer[0]);
				lr = getShort(&working_buffer[2]);
				fc = working_buffer[4];
				lc = working_buffer[5];
				for (i=fr; i<=lr; i++)
				{
					for (j=fc; j<=lc; j++)
						add_wb_array(i, j, (U16)0, opcode, 0, (U8 *)"***Array", 8, 0, 0);
				}
				NotImplemented = 1;
			}
			break;
		case 0xBD:		/* MULRK */
			working_buffer[bufidx++] = data;
			if (bufidx == last)
			{
				U16 r, fc, lc;
				int i;
				r = getShort(&working_buffer[0]);
				fc = getShort(&working_buffer[2]);
				lc = getShort(&working_buffer[last-2]);
				for (i=0; i<=(lc-fc); i++)
				{
					U32 t;
					S32 n2, n;		/* Must be signed long !!! */
					U16 f;
					F64 d;
					char temp[64];

					f = getShort(&working_buffer[4+(i*6)]);
					n = getLong(&working_buffer[6+(i*6)]);
					t = n & 0x03;
					n2 = n>>2;
					switch (t)
					{
						case 0:
							RKtoDouble(n2, &d);
							sprintf(temp, "%.15g", d);
							break;
						case 1:
							RKtoDouble(n2, &d);
							sprintf(temp, "%.15g", d / 100.0);
							break;
						case 2:
							sprintf(temp, " %ld", (S32)n2);
							break;
						default:
							d = (F64) n2;
							sprintf(temp, "%.15g",  d / 100.0 );
							break;
					}
/*					printf("%08X %02X %s  %d  %d\n", n2, t, temp, r, fc+i); */
					add_wb_array(r, fc+i, f, opcode, (U16)0, (U8 *)temp, (U16)strlen(temp), 0, 0);
				}
			}
			break;
		case 0xBE:		/* MULBLANK */
			working_buffer[bufidx++] = data;
			if (bufidx == last)
			{
				U16 r, fc, lc, j, f;
				r = getShort(&working_buffer[0]);
				fc = getShort(&working_buffer[2]);
				lc = getShort(&working_buffer[last-2]);
				for (j=0; j<=(lc-fc); j++)
				{	/* This just stores format strings... */
					f = getShort(&working_buffer[4+(j*2)]);
					add_wb_array(r, fc+j, f, opcode, (U16)0, (U8 *)0, (U16)0, 0, 0);
				}
			}
			break;
		case 0x18:		/* Name UNI */
			working_buffer[bufidx++] = data;
			if (bufidx == last)
			{
				char *ptr;
				working_buffer[bufidx] = 0;
				ptr = (char *)strstr((char *)&working_buffer[15], "LastUpdate");
				if (ptr)
				{
					ptr += 13;
					lastUpdated = (char *)malloc(strlen(ptr)+1);
					if (lastUpdated)
						strcpy(lastUpdated, ptr);
				}
				else
				{
					ptr = (char *)strstr((char *)&working_buffer[15], "Title");
					if (ptr)
					{
						ptr += 8;
						title = (char *)malloc(strlen(ptr)+1);
						if (title)
							strcpy(title, ptr);
					}
				}
			}
			break;
		case 0xE0:		/* Extended format */
			working_buffer[bufidx++] = data;
			if (bufidx == last)
			{
				U16 fnt_idx;
				U16 fmt_idx;
				U16 gen;
				U16 align;
				U16 indent;
				U16 b_style;
				U16 b_l_color;
				U32  b_t_color;
				U16 cell_color;

				fnt_idx = getShort(&working_buffer[0]);
				fmt_idx = getShort(&working_buffer[2]);
				gen = getShort(&working_buffer[4]);
				align  = getShort(&working_buffer[6]);
				indent  = getShort(&working_buffer[8]);
				b_style  = getShort(&working_buffer[10]);
				if (file_version == EXCEL95)
				{
					b_l_color  = 0;
					b_t_color = 0;
					cell_color  = (U16)(getShort(&working_buffer[12]) & (U16)0x1FFF);
				}
				else	/* Excel 97 + */
				{
					b_l_color  = getShort(&working_buffer[12]);
					b_t_color = getLong(&working_buffer[14]);
					cell_color  = getShort(&working_buffer[18]);
				}

				/* printf("XF:%02X FG:%02X BG:%02X\n", next_xf, cell_color&0x007F, (cell_color&0x1F80)>>7); */
				/* printf("XF:%02X M:%02X b_t:%04X<br>\n", next_xf, indent, b_t_color); */
				add_xf_array(fnt_idx, fmt_idx, gen, align, indent, b_style,
					b_l_color, b_t_color, cell_color);
			}
			break;
		case 0xE5:		/* CELL MERGE INSTRUCTIONS */
			working_buffer[bufidx++] = data;
			if (bufidx == last)
			{
				U16 num, fr, lr, fc, lc, i, j, k;
				ws_array[sheet_count]->spanned = 1;
				num = getShort(&working_buffer[0]);
				if (ws_array[sheet_count]->c_array == 0)
					return;

				for (i=0; i<num; i++)
				{
					cell *c;
					fr = getShort(&working_buffer[2+(i*8)]);
					lr = getShort(&working_buffer[4+(i*8)]);
					fc = getShort(&working_buffer[6+(i*8)]);
					lc = getShort(&working_buffer[8+(i*8)]);
					if (sheet_count < (int)max_worksheets)
					{
						if (ws_array[sheet_count] == 0)
						{
							if (ws_init(sheet_count))
								return;
						}
						if (ws_array[sheet_count]->c_array)
						{
							if ((fr > lr)||(fr > ws_array[sheet_count]->biggest_row)||(lr > ws_array[sheet_count]->biggest_row))
								lr = (U16)ws_array[sheet_count]->biggest_row;
							if ((fc > lc)||(fc > ws_array[sheet_count]->biggest_col)||(lc > ws_array[sheet_count]->biggest_col))
								lc = ws_array[sheet_count]->biggest_col;
							for(j=fr; j<=lr; j++)
							{	/* For each row */
								for(k=fc; k<=lc; k++)
								{	/* for each column */
									c = ws_array[sheet_count]->c_array[(j*ws_array[sheet_count]->max_cols)+k];
									if (c != 0)
									{
										c->spanned = 1;
										c->rowspan = 0;
										if (k == fc)
											c->colspan = (U16)((lc-fc)+1);
										else
											c->colspan = 0;
									}
/*									else
									{	/ Need to create one...
										printf("Bad One at:%d %d %d<br>\n", sheet_count, j, k);
									} */
								}
							}
						}
						/* Now reset the first one... */
/*						printf("s:%d fr:%d fc:%d lr:%d lc:%d<br>\n", sheet_count, fr, fc, lr, lc); */
						c = ws_array[sheet_count]->c_array[(fr*ws_array[sheet_count]->max_cols)+fc];
						if (c != 0)
						{
							c->spanned = 0;
							c->rowspan = (U16)(lr-fr);
							c->colspan = (U16)(lc-fc);
							if (c->rowspan)
								c->rowspan++;
							if (c->colspan)
								c->colspan++;
						}
					}
				}
			}
			break;
		case 0xB8:	/* Hyperlink */
			working_buffer[bufidx++] = data;
			if (bufidx == last)
			{	/* This is based on Office 97 info... */
				U16 r, c, uni_type, off;
				U32 len;

				r = getShort(&working_buffer[0]);
				c = getShort(&working_buffer[4]);
				if (working_buffer[32] == 0xE0)
				{	/* Unicode format */
					len = getLong(&working_buffer[48]);
					off = 52;
					uni_type = 2;
				}
				else
				{	/* Ascii format */
					len = getLong(&working_buffer[50]);
					off = 54;
					uni_type = 0;
				}
				if (len > (U32)(bufidx - off))
				{	/* correct misidentified li