xlhtml.c~

excel to html

			break;
		case 0x01:	/* Blank */
			working_buffer[bufidx++] = data;
			if (bufidx == last)
			{
				U16 r, c, f;

				r = getShort(&working_buffer[0]);
				c = getShort(&working_buffer[2]);
				if (version == 2)
					f = getShort(&working_buffer[4]);
				else
					f = 0;
				add_wb_array(r, c, f, opcode, (U16)0, (U8 *)0, 0, (U16)0, 0);
			}
			break;
		case 0x02:	/* Integer */
			working_buffer[bufidx++] = data;		
			if (bufidx == last)
			{
				U16 r, c, i, f;
				char temp[32];

				r = getShort(&working_buffer[0]);
				c = getShort(&working_buffer[2]);
				if (version == 2)
				{
					f = getShort(&working_buffer[4]);
					i = getShort(&working_buffer[7]);
					sprintf(temp, "%d", i);
				}
				else
				{
					f = 0;
					Unsupported++;
					strcpy(temp, OutputXML ? "<Unsupported/>INT" : "****INT");
				}
				add_wb_array(r, c, f, opcode, (U16)0, (U8 *)temp, (U16)strlen(temp), 0, NULL);
			}		
			break;
		case 0x03:	/* Number - Float */
			working_buffer[bufidx++] = data;
			if (bufidx == last)
			{
				U16 r, c, f;
				F64 d;
				char temp[64];

				r = getShort(&working_buffer[0]);
				c = getShort(&working_buffer[2]);
				if (version == 2)
				{
					f = getShort(&working_buffer[4]);
					getDouble(&working_buffer[6], &d);
					sprintf(temp, "%.15g", d);
				}
				else
				{	/* Who knows what the future looks like */
					f = 0;
					Unsupported = 1;
					sprintf(temp, "****FPv:%d", version);
				}
				add_wb_array(r, c, f, opcode, (U16)0, (U8 *)temp, (U16)strlen(temp), 0, 0);
			}
			break;
		case 0xD6:	/* RString */
			working_buffer[bufidx++] = data;		
			if ((bufidx == 7)&&(buflast == 0))
				buflast = working_buffer[7];
			if (buflast)
			{
				if (bufidx == buflast)
				{
					U16 r, c, l, f;

					r = getShort(&working_buffer[0]);
					c = getShort(&working_buffer[2]);
					f = getShort(&working_buffer[4]);
					l = getShort(&working_buffer[6]);
					working_buffer[8+l] = 0;

					add_wb_array(r, c, f, opcode, (U16)0, &working_buffer[8],
							(U16)strlen((char *)&working_buffer[8]), 0, 0);
				}
			}
			break;
		case 0x04:	/* Label - UNI */
			working_buffer[bufidx++] = data;
			if (file_version == EXCEL95)
			{
				if (bufidx == last)
				{
					U16 r, c, f;

					r = getShort(&working_buffer[0]);
					c = getShort(&working_buffer[2]);
					f = getShort(&working_buffer[4]);
					working_buffer[bufidx] = 0;

					add_wb_array(r, c, f, opcode, (U16)0, &working_buffer[8],
							(U16)strlen((char *)&working_buffer[8]), 0, 0);
				}
			}
			else if (file_version == EXCEL97)
			{    /* Remember, bufidx is 1 more than it should be */
				if ((bufidx == 8)&&(buflast == 0))
				{	/* buflast = working_buffer[7]; */
					cch = getShort(&working_buffer[6]);
					buflast = cch + 9;
				}
				if (bufidx == 9)
				{
					if (working_buffer[8] == 1)
						buflast = (cch << 1) + 9;
				}
				if (buflast)
				{
					if (bufidx == buflast)
					{
						U16 r, c, f;
						U16 len;

						r = getShort(&working_buffer[0]);
						c = getShort(&working_buffer[2]);
						if (version == 2)
							f = getShort(&working_buffer[4]);
						else	/* Unknown version */
							f = 0;
						working_buffer[bufidx] = 0;

						len = (U16)strlen((char *)&working_buffer[8]);
						if (working_buffer[8] == 1)
						{
							UnicodeStrings = 2;
							add_wb_array(r, c, f, opcode, (U16)2, &working_buffer[9], (U16)(cch << 1), 0, 0);
						}
						else
							add_wb_array(r, c, f, opcode, (U16)0, &working_buffer[8], len, 0, 0);
					}
				}
			}
			break;
		case 0x05:	/* Boolerr */
			working_buffer[bufidx++] = data;
			if (bufidx == last)
			{
				U16 r, c, f;
				char temp[16];

				r = getShort(&working_buffer[0]);
				c = getShort(&working_buffer[2]);
				if (version == 2)
				{
					f = getShort(&working_buffer[4]);
					decodeBoolErr(working_buffer[6], working_buffer[7], temp);
					add_wb_array(r, c, f, opcode, (U16)0, (U8 *)temp, (U16)strlen(temp), 0, 0);
				}
				else
				{
					f = 0;
					Unsupported = 1;
					strcpy(temp, "****Bool");
					add_wb_array(r, c, f, opcode, (U16)0, (U8 *)temp, (U16)strlen(temp), 0, 0);
				}
			}
			break;
			/************
			*	This function has 2 entry points. 1 is the mainline FC opcode.
			*	In this event there are several bytes that setup the type of
			*	strings that will follow. Then there is the continue entry
			*	point which is immediate - e.g location 0.
			*************/
		case 0xFC:	/* Packed String Array A.K.A. SST Shared String Table...UNI */
			if ((count > 7)||(cont_opcode == 1)) /* Skip the 1st 8 locations they are bs */
			{
/*				if ((count == 0)&&(data == 0)&&(buflast))	*/
				if ((count == 0)&&(cont_opcode == 1)&&(buflast))
				{
/*					printf("Adjusting...\n"); */
/*					printf("I:%04X BL:%04X\n", bufidx, buflast); */
					cont_str_array = 1;
					cont_grbit = data;
					return;
				}

				working_buffer[bufidx] = data;
				bufidx++;

				if((cont_str_array)&&(grbit & 0x01)&& !(cont_grbit & 0x01))
				{	/* ASCII -> unicode */
					working_buffer[bufidx] = 0;
					bufidx++;
				}

				if (buflast == 0)	/* Header processor */
				{
					if (bufidx == 0x03)  /* After 3 locations we have length */
					{				    /* and type of chars... */
						cch = getShort(&working_buffer[0]);
						grbit = working_buffer[2];

						if (grbit < 0x04)	/* Normal run */
						{
							nonascii = 0;
							bufidx = 0;
							crun = 0;
							extrst = 0;
							buflast = cch << (grbit & 0x01);

							/* special case for empty strings */
							if (!cch && !buflast)
								add_str_array(0, (U8 *)0, 0, 0, 0);
							else
								memset(working_buffer, 0, WBUFF_SIZE);
						}
					}
					else if (bufidx == 0x05)
					{
						if ((grbit & 0x0C) == 0x08)	/* Rich string only */
						{
							nonascii = 0;
							bufidx = 0;
							crun = getShort(&working_buffer[3]);
							extrst = 0;
							buflast = (cch << (grbit & 0x01)) + (crun*4);
/*							printf("rtbuflast:%X cch%X grbit:%X extrst:%X crun:%X last:%X\n",
										buflast, cch, grbit, extrst, crun, last);
							printf("%02X %02X %02X %02X %02X %02X\n",
							working_buffer[0], working_buffer[1], working_buffer[2],
							working_buffer[3], working_buffer[4], working_buffer[5]); */
							memset(working_buffer, 0, WBUFF_SIZE);
						}
					}
					else if (bufidx == 0x07)
					{
						if ((grbit & 0x0C) == 0x04)	/* Extended string only */
						{
							nonascii = 0;
							bufidx = 0;
							crun = 0;
							extrst = getLong(&working_buffer[3]);
							buflast = (cch << (grbit & 0x01)) + extrst;
/*							printf("esbuflast:%X cch%X grbit:%X extrst:%X last:%X\n",
										buflast, cch, grbit, extrst, last);
							printf("%02X %02X %02X %02X %02X %02X\n",
							working_buffer[0], working_buffer[1], working_buffer[2],
							working_buffer[3], working_buffer[4], working_buffer[5]); */
							memset(working_buffer, 0, WBUFF_SIZE);
						}
					}
					else if (bufidx == 0x09)
					{
						if ((grbit & 0x0C) == 0x0C)
						{
							/* Rich String + Extended String **/
							nonascii = 0;
							bufidx = 0;
							crun = getShort(&working_buffer[3]);
							extrst = getLong(&working_buffer[5]);
							buflast = (cch << (grbit & 0x01)) + extrst + (crun*4);
/*							printf("xrtbuflast:%X cch%X grbit:%X extrst:%X crun:%X last:%X\n",
										buflast, cch, grbit, extrst, crun, last);
							printf("%02X %02X %02X %02X %02X %02X\n",
							working_buffer[0], working_buffer[1], working_buffer[2],
							working_buffer[3], working_buffer[4], working_buffer[5]); */
							memset(working_buffer, 0, WBUFF_SIZE);
						}
					}
/*					printf("*%02X ", data); */
				}
				else	/* payload processor */
				{
/*					if (cont_opcode == 1)
						printf(" %02X", data); */
					if (data > 127)
						nonascii = 1;
					if (bufidx == buflast)
					{
						U8 uni;
						U16 len = (U16)(cch << (grbit & 0x01));
/*						int i;	*/

						if (grbit & 01)
						{
							uni = 2;
							UnicodeStrings = 2;
						}
						else
							uni = nonascii;
						working_buffer[bufidx] = 0;
/*  						fprintf(stderr,":buflast-"); */
/*                                                  { int i; */
/*  						for (i=0; i<buflast; i++) */
/*                                                    putchar(working_buffer[i]); */
/*  						fprintf(stderr,"\nNext String:%d\n", next_string); */
/*                                                  } */

						if (crun)
							add_str_array(uni, working_buffer, len, working_buffer+len, crun);
						else
							add_str_array(uni, working_buffer, len, 0, 0);
						if (uni > UnicodeStrings)	/* Try to "upgrade" charset */
							UnicodeStrings = uni;
						bufidx = 0;
						buflast = 0;
						cch = 0;
						cont_str_array = 0;
						memset(working_buffer, 0, WBUFF_SIZE);
					}
				}
			}
			break;
		case 0xFD:	/* String Array Index A.K.A. LABELSST */
			working_buffer[count] = data;
			if (count == (last - 1))
			{
				U32 i;
				U16 r, c, f;

				/* This is byte reversed... */
				r = getShort(&working_buffer[0]);
				c = getShort(&working_buffer[2]);
				f = getShort(&working_buffer[4]);
				i = getLong(&working_buffer[6]);
				if (i < next_string)
				{
/*					printf("String used:%d\n", (int)i); */
					if (str_array[i])
					{
						if (str_array[i]->str)
							add_wb_array(
								r, c, f, opcode,
								str_array[i]->uni, str_array[i]->str,
								str_array[i]->len, str_array[i]->crun_cnt, str_array[i]->fmt_run);
					}
					else	/* Error, so just set it empty */
						add_wb_array( r, c, f, opcode,
								(U16)0, (U8 *)"String Table Error", 18, 0, 0);
				}
				else
					MaxStringsExceeded = 1;
			}
			break;
		case 0x31:	/* Font */
			working_buffer[bufidx++] = data;
			if (bufidx > 14) /* Address 14 has length in unicode chars */
			{
				if ((file_version == EXCEL95)&&(bufidx == last))
				{	/* Microsoft doesn't stick to their documentation. Excel 97 is supposed
					   to be 0x0231...but its not. Have to use file_version to separate them. */
					unsigned int i;
					U16 size, attr, c_idx, b, su;
					U8 u;

					size = getShort(&working_buffer[0]);
					attr = getShort(&working_buffer[2]);
					c_idx = getShort(&working_buffer[4]);
					b = getShort(&working_buffer[6]);
					su = getShort(&working_buffer[8]);
					u = working_buffer[10];
					buflast = working_buffer[14];
					for (i=0; i<buflast; i++)
						working_buffer[i] = working_buffer[i+15];

					working_buffer[buflast] = 0;
/*					printf("S:%04X A:%04X C:%04X B:%04X SU:%04X U:%02X\n",
							size, attr,c_idx,b,su,u);
					printf("f:%s\n", working_buffer); */
					add_font(size, attr, c_idx, b, su, u, 0, &working_buffer[0], 0);
				}
				else if ((file_version == EXCEL97)&&(bufidx == last))
				{	/* Microsoft doesn't stick to their documentation. Excel 97 is supposed
					   to be 0x0231...but its not. Have to use file_version to separate them. */
					unsigned int i;
					U16 len;
					U16 size, attr, c_idx, b, su;
					U8 u, uni=0;

					size = getShort(&working_buffer[0]);
					attr = getShort(&working_buffer[2]);
					c_idx = getShort(&working_buffer[4]);
					b = getShort(&working_buffer[6]);
					su = getShort(&working_buffer[8]);
					u = working_buffer[10];
					buflast = working_buffer[14];

					for (i=0; i<(buflast-2); i++)
					{	/* This looks at the 2nd byte to see if its unicode... */
						if (working_buffer[(i<<1)+17] != 0)
							uni = 2;
					}

					if (uni == 2)
						len = (U16)(buflast<<1);
					else
						len = (U16)buflast;

					if (uni == 0)
					{	
						for (i=0; i<len; i++)
						{
							working_buffer[i] = working_buffer[(i<<1)+16];
							if ((working_buffer[i] > 0x0080U) && (uni == 0))
								uni = 1;
						}
					}
					else
					{
						for (i=0; i<len; i++)
							working_buffer[i] = working_buffer[i+16];
					}

					working_buffer[len] = 0;

/*					printf("S:%04X A:%04X C:%04X B:%04X SU:%04X U:%02X\n",
							size, attr,c_idx,b,su,u);
					printf("BL:%d L:%d Uni:%d\n", buflast, len, uni);
					printf("%X %X %X %X\n", working_buffer[15], working_buffer[16], working_buffer[17], working_buffer[18]);
					printf("f:%s\n", working_buffer); */
					add_font(size, attr, c_idx, b, su, u, uni, &working_buffer[0], len);
				}
			}
			break;
		case 0x14:	/* Header */
			break;
		case 0x15:	/* Footer */
			break;
		case 0x06:	/* Formula */
			working_buffer[bufidx++] = data;
			if (bufidx == last)
			{
				U16 r, c, f;
				U8 calc_val[64];

				r = getShort(&working_buffer[0]);
				c = getShort(&working_buffer[2]);
				f = getShort(&working_buffer[4]);
				if ((working_buffer[12] == 0xFF)&&(working_buffer[13] == 0xFF))
				{	/* Formula evaluates to Bool, Err, or String */
					if (working_buffer[6] == 1)				/* Boolean */
					{
						decodeBoolErr(working_buffer[8], 0, (char *)calc_val);
						opcode = 0x0105;
					}
					else if (working_buffer[6] == 2)			/* Err */
					{
						decodeBoolErr(working_buffer[8], 1, (char *)calc_val);
						opcode = 0x0105;
					}
					else
					{							/* String UNI */
						str_formula_row = r;
						str_formula_col = c;
						str_formula_format = f;
						break;
					}
				}
				else
				{	/* Otherwise...this is a number */
					F64 n;
					getDouble(&working_buffer[6], &n);
					sprintf((char *)calc_val, "%.15g", n);
					opcode = 0x0103;	/* To fix up OutputCellFormatted... */
				}
				add_wb_array(r, c, f, opcode, (U16)0, calc_val, (U16)strlen((char *)calc_val), 0, 0);
			}
			break;
		case 0x07:	/* String Formula Results */
			working_buffer[bufidx++] = data;
			if (bufidx == last)
			{
				U8 *str;
				U8 uni = 0;
				U16 len = getShort(&working_buffer[0]);