reachableceo/xlhtml
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
b9ef2ed71e
xlhtml/xlhtml/xlhtml.c
slidedraw 4b5e11f7a7 Cut 0.5 release
2002-04-11 03:25:17 +00:00

3916 lines
94 KiB
C
Raw Blame History

/*! \file xlhtml.c
\brief converts excel files to Html
xlhtml generates HTML, XML, csv and tab-delimitted versions of Excel
spreadsheets.
*/
/*
Copyright 2002 Charles N Wyble <jackshck@yahoo.com>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "tuneable.h"
#include "xlhtml.h"
static char SectionName[2][12] = /* The section of the Excel Stream where the workbooks are kept */
{
"/Workbook", /*!< Excel 97 & 2000 */
"/Book" /*!< Everything else ? */
};
int numCustomColors = 0;
U8 **customColors = 0;
char colorTab[MAX_COLORS][8] =
{
"000000", /* FIXME: Need to find these first 8 colors! */
"FFFFFF",
"FFFFFF",
"FFFFFF",
"FFFFFF",
"FFFFFF",
"FFFFFF",
"FFFFFF",
"FFFFFF", /*0x08 - This one's Black, too ??? */
"FFFFFF", /* This one's normal */
"red", /* "FF0000", */
"lime", /* "00FF00", */
"blue", /* "0000FF", */
"FFFF00",
"FF00FF",
"aqua", /* "00FFFF", */
"800000", /* 0x10 */
"green", /* "008000", */
"navy", /* "000080", */
"808000",
"800080",
"teal", /* "008080", */
"C0C0C0",
"gray", /* "808080", */
"9999FF", /* 0x18 */
"993366",
"FFFFCC",
"CCFFFF",
"660066",
"FF8080",
"0066CC",
"CCCCFF",
"000080",
"FF00FF", /* 0x20 */
"FFFF00",
"00FFFF",
"800080",
"800000",
"008080",
"0000FF",
"00CCFF", /* 0x28 */
"CCFFFF",
"CCFFCC",
"FFFF99",
"99CCFF",
"FF99CC",
"CC99FF",
"FFCC99",
"3366FF", /* 0x30 */
"33CCCC",
"99CC00",
"FFCC00",
"FF9900",
"FF6600",
"666699",
"969696",
"003366", /* 0x38 */
"339966",
"003300",
"333300",
"993300",
"993366",
"333399",
"333333",
"FFFFFF" /* 0x40 */
};
int DatesR1904 = 0; /*!< Flag that the dates are based on McIntosh Dates system */
/* FIXME: Support major languages here...not just English */
const char month_abbr[12][5] = { "Jan", "Feb", "Mar", "Apr", "May", "June",
"July", "Aug", "Sep", "Oct", "Nov", "Dec" };
/* Function Prototypes */
/* These functions are in support.c */
extern void print_version(void);
extern void display_usage(void);
extern void do_cr(void);
extern void OutputTableHTML(void);
extern S32 getLong(U8 *);
extern U16 getShort(U8 *);
extern void getDouble(U8 *, F64 *);
extern int null_string(U8 *);
extern void FracToTime(U8 *, int *, int *, int *, int *);
extern void NumToDate(long, int *, int *, int *);
extern void RKtoDouble(S32, F64 *);
/* This function is in xml.c */
extern void OutputTableXML(void);
/* This function is in ascii.c */
void OutputPartialTableAscii(void);
/* These functions are in html.c */
extern void output_start_html_attr(html_attr *h, unsigned int, int);
extern void output_end_html_attr(html_attr *h);
extern void output_footer(void);
extern void output_header(void);
COLE_LOCATE_ACTION_FUNC scan_file;
void main_line_processor(U16, U16, U32, U16, U8);
void SetupExtraction(void);
void decodeBoolErr(U16, U16, char *);
int IsCellNumeric(cell *);
int IsCellSafe(cell *);
int IsCellFormula(cell *);
void output_cell(cell *, int);
void output_formatted_data(uni_string *, U16, int, int);
void PrintFloatComma(char *, int, F64);
void print_as_fraction(F64, int);
void trim_sheet_edges(unsigned int);
void update_default_font(unsigned int);
void incr_f_cnt(uni_string *);
int get_default_font(void);
void update_default_alignment(unsigned int, int);
void OutputString(uni_string *);
void OutputCharCorrected(U8);
void update_crun_info(U16 *loc, U16 *fnt_idx, U16 crun_cnt, U8 *fmt_run);
void put_utf8(U16);
void print_utf8(U16);
void uni_string_clear(uni_string *);
int uni_string_comp(uni_string *, uni_string *);
void html_flag_init(html_attr *h);
void output_start_font_attribute(html_attr *h, U16 fnt_idx);
/* The array update functions */
int ws_init(int);
int add_more_worksheet_ptrs(void);
int resize_c_array(work_sheet *, U32, U16);
void add_wb_array(U16, U16, U16, U16, U8, U8 *, U16, U16, U8 *);
void update_cell_xf(U16, U16, U16);
void update_cell_hyperlink(U16 r, U16 c, U8 *hyperlink, int len, U16 type);
void add_str_array(U8, U8 *, U16, U8 *, U8);
void add_font(U16, U16, U16, U16, U16, U8, U16, U8 *, U16);
void add_ws_title(U16, U8 *, U16);
void add_xf_array(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);
/* Global data */
char filename[256];
int file_version = 0;
U32 next_string=0;
unsigned int next_font=0, next_ws_title=0, next_xf=0;
U8 working_buffer[WBUFF_SIZE];
unsigned int bufidx, buflast; /*!< Needed for working buffer */
U8 grbit=0; /*!< Needed by the SST Opcode FC */
U16 crun=0, cch=0; /*!< Needed by the SST Opcode FC */
U32 extrst=0; /*!< Needed by the SST Opcode FC */
U16 nonascii = 0; /*!< Needed by the SST Opcode FC */
int sheet_count=-2; /*!< Number of worksheets found */
U16 last_opcode = -1; /*!< Used for the continue command */
unsigned int cont_grbit=0, cont_str_array=0;
uni_string default_font; /*!< Font for table */
int default_fontsize = 3; /*!< Default font size for table */
char *default_alignment = 0; /*!< Alignment for table */
int first_sheet = 0; /*!< First worksheet to display */
int last_sheet = WORKSHEETS_INCR-1; /*!< The last worksheet to display */
S16 xp=0, xr1=-1, xr2=-1, xc1=-1, xc2=-1; /*!< Extraction info... */
int currency_symbol = '$'; /*!< What to use for currency */
U16 str_formula_row = 0; /*!< Data holders for string formulas */
U16 str_formula_col = 0; /*!< Data holders for string formulas */
U16 str_formula_format = 0; /*!< Data holders for string formulas */
/* Limits */
unsigned int max_fonts = FONTS_INCR;
unsigned int max_xformats = XFORMATS_INCR;
unsigned long max_strings = STRINGS_INCR;
unsigned int max_worksheets = WORKSHEETS_INCR;
/* Global arrays */
xf_attr **xf_array;
work_sheet **ws_array;
uni_string **str_array;
font_attr **font_array;
fnt_cnt *f_cnt;
int fnt_size_cnt[7]; /*!< Html has only 7 sizes... */
uni_string author;
char *title = 0;
char *lastUpdated = 0;
/* Command Line flags */
int use_colors = 1; /*!< Whether or not to use colors in output */
int aggressive = 0; /*!< Aggressive html optimization */
int formula_warnings = 1; /*!< Whether or not to suppress formula warnings */
int center_tables = 0; /*!< Whether or not to center justify tables or leave it left */
int trim_edges = 0; /*!< Whether or not to trim the edges of columns or rows */
char *default_text_color = "000000";
char *default_background_color="FFFFFF";
char *default_image=NULL; /*!< Point to background image */
int Ascii = 0; /*!< Whether or not to out ascii instaed of html */
int Csv = 0; /*!< Whether or not to out csv instaed of html */
int OutputXML = 0; /*!< Output as xml */
int DumpPage = 0; /*!< Dump page count & max cols & rows */
int Xtract = 0; /*!< Extract a range on a page. */
int MultiByte = 0; /*!< Output as multibyte */
int NoHeaders = 0; /*!< Dont output html header */
/* Some Global Flags */
int notAccurate = 0; /*!< Flag used to indicate that stale data was used */
int NoFormat = 0; /*!< Flag used to indicated unimplemented format */
int NotImplemented = 0; /*!< Flag to print unimplemented cell type message */
int Unsupported = 0; /*!< Flag to print unsupported cell type message */
int MaxPalExceeded = 0;
int MaxXFExceeded = 0;
int MaxFormatsExceeded = 0;
int MaxColExceeded = 0;
int MaxRowExceeded = 0;
int MaxWorksheetsExceeded = 0;
int MaxStringsExceeded = 0;
int MaxFontsExceeded = 0;
int UnicodeStrings = 0; /*!< 0==ASCII, 1==windows-1252, 2==uft-8 */
int CodePage = 0; /*!< Micosoft CodePage as specified in the Excel file. */
int main (int argc, char **argv)
{
int i, f_ptr = 0;
U16 k;
U32 j;
COLEFS * cfs;
COLERRNO colerrno;
if (argc < 2)
{
printf("Incorrect usage. Try xlhtml --help for more information\n");
exit(0);
}
else
{
strncpy(filename, argv[argc-1], 252);
filename[252] = 0;
for (i=1; i<(argc-1); i++)
{
if (strcmp(argv[i], "-nc") == 0)
use_colors = 0;
else if(strcmp(argv[i], "-xml") == 0 )
OutputXML = 1;
else if (strcmp(argv[i], "-asc") == 0)
Ascii = 1;
else if (strcmp(argv[i], "--ascii") == 0)
Ascii = 1;
else if (strcmp(argv[i], "-csv") == 0)
{
Ascii = 1;
Csv = 1;
}
else if (strcmp(argv[i], "-a") == 0)
aggressive = 1;
else if (strcmp(argv[i], "-fw") == 0)
formula_warnings = 0;
else if (strcmp(argv[i], "-c") == 0)
center_tables = 1;
else if (strcmp(argv[i], "-dp") == 0)
DumpPage = 1;
else if (strcmp(argv[i], "-m") == 0)
MultiByte = 1;
else if (strncmp(argv[i], "-tc", 3) == 0)
{
default_text_color = &argv[i][3];
if (strlen(default_text_color) != 6)
display_usage();
}
else if (strncmp(argv[i], "-bc", 3) == 0)
{
default_background_color = &argv[i][3];
if (strlen(default_background_color) != 6)
display_usage();
}
else if (strncmp(argv[i], "-bi", 3) == 0)
{
default_image = &argv[i][3];
use_colors = 0;
}
else if (strncmp(argv[i], "-te", 3) == 0)
trim_edges = 1;
else if (strcmp(argv[i], "-v") == 0)
print_version();
else if(strcmp(argv[i], "-nh") == 0 )
NoHeaders = 1;
else if (strncmp(argv[i], "-xc:", 4) == 0)
{
int d1, d2;
if (sscanf(argv[i] + 4, "%d-%d", &d1, &d2) != 2)
{
fprintf(stderr, "column range %s not valid, expected -xc:FIRST-LAST\n", argv[i] + 4);
display_usage();
}
xc1 = (S16)d1;
xc2 = (S16)d2;
Xtract = 1;
if (xc1 > xc2)
{
fprintf(stderr, "last column must be >= the first\n");
exit(1);
}
}
else if (strncmp(argv[i], "-xp:", 4) == 0)
{
Xtract = 1;
xp = (S16)atoi(&(argv[i][4]));
if (xp < 0)
{
fprintf(stderr, "Negative numbers are illegal.\n");
exit(1);
}
}
else if (strncmp(argv[i], "-xr:", 4) == 0)
{
char *ptr, *buf;
Xtract = 1;
buf = strdup(argv[i]);
ptr = strrchr(buf, '-');
xr2 = (S16)atoi(ptr+1);
*ptr = 0;
ptr = strchr(buf, ':');
xr1 = (S16)atoi(ptr+1);
free(buf);
if (xr1 > xr2)
{
fprintf(stderr, "row's 2nd digit must be >= the first\n");
exit(1);
}
}
else
display_usage();
}
if (strcmp(filename, "-v") == 0)
{
print_version();
}
if (strcmp(filename, "--version") == 0)
{
print_version();
}
if (strcmp(filename, "--help") == 0)
display_usage();
if (strcmp(filename, "-?") == 0)
display_usage();
}
if (Ascii)
{ /* Disable it if DumpPage or Xtract isn't used... */
if (!(DumpPage||Xtract))
Ascii = 0;
}
if (Xtract)
trim_edges = 0; /* No trimming when extracting... */
if (OutputXML)
aggressive = 0;
/* Init arrays... */
ws_array = (work_sheet **)malloc(max_worksheets * sizeof(work_sheet *));
for (i=0; i<(int)max_worksheets; i++)
ws_array[i] = 0;
str_array = (uni_string **)malloc(max_strings*sizeof(uni_string *));
for (i=0; i<(int)max_strings; i++)
str_array[i] = 0;
font_array = (font_attr **)malloc(max_fonts * sizeof(font_attr *));
f_cnt = (fnt_cnt *)malloc(max_fonts * sizeof(fnt_cnt));
for (i=0; i<(int)max_fonts; i++)
{ /* I assume these won't fail since we are just starting up... */
font_array[i] = 0;
f_cnt[i].name = 0;
}
xf_array = (xf_attr **)malloc(max_xformats * sizeof(xf_attr *));
for (i=0; i<(int)max_xformats; i++)
xf_array[i] = 0;
uni_string_clear(&author);
uni_string_clear(&default_font);
umask(GLOBAL_UMASK);
#if defined( __WIN32__ ) || defined( __BORLANDC__ )
{
char *ptr = strchr(filename, ':');
if (ptr)
{
int len;
char new_drive[MAXPATH];
fnsplit(filename, new_drive, 0, 0, 0);
if (new_drive[0] >= 'a')
setdisk(new_drive[0] - 'a');
else
setdisk(new_drive[0] - 'A');
ptr++; /* Get past the colon */
len = strlen(ptr);
memmove(filename, ptr, len);
filename[len] = 0;
}
}
#endif
/* If successful, this calls scan_file to extract the work book... */
cfs = cole_mount(filename, &colerrno);
if (cfs == NULL)
{
cole_perror (NULL, colerrno);
exit(1);
}
while (cole_locate_filename (cfs, SectionName[f_ptr], NULL, scan_file, &colerrno))
{
if (f_ptr)
{ /* Two strikes...we're out! */
cole_perror (PRGNAME, colerrno);
if (colerrno == COLE_EFILENOTFOUND)
fprintf(stderr, "Section: Workbook\n");
break;
}
else
f_ptr++;
}
if (cole_umount (cfs, &colerrno))
{
cole_perror (PRGNAME, colerrno);
exit(1);
}
for (i=0; i<max_strings; i++)
{
if (str_array[i])
{
if (str_array[i]->str)
free(str_array[i]->str);
free(str_array[i]);
}
}
for (i=0; i<(int)max_fonts; i++)
{
if (font_array[i])
{
if (font_array[i]->name.str)
free(font_array[i]->name.str);
free(font_array[i]);
if (f_cnt[i].name)
{
if (f_cnt[i].name->str)
free(f_cnt[i].name->str);
free(f_cnt[i].name);
}
}
}
for (i=0; i<(int)max_worksheets; i++)
{
if (ws_array[i])
{
if (ws_array[i]->ws_title.str)
free(ws_array[i]->ws_title.str);
if (ws_array[i]->c_array)
{
for (j=0; j<ws_array[i]->max_rows; j++)
{
for (k=0; k<ws_array[i]->max_cols; k++)
{
if (ws_array[i]->c_array[(j*ws_array[i]->max_cols)+k])
{
if (ws_array[i]->c_array[(j*ws_array[i]->max_cols)+k]->ustr.str)
free(ws_array[i]->c_array[(j*ws_array[i]->max_cols)+k]->ustr.str);
if (ws_array[i]->c_array[(j*ws_array[i]->max_cols)+k]->ustr.fmt_run)
free(ws_array[i]->c_array[(j*ws_array[i]->max_cols)+k]->ustr.fmt_run);
if (ws_array[i]->c_array[(j*ws_array[i]->max_cols)+k]->h_link.str)
free(ws_array[i]->c_array[(j*ws_array[i]->max_cols)+k]->h_link.str);
free(ws_array[i]->c_array[(j*ws_array[i]->max_cols)+k]);
}
}
}
free(ws_array[i]->c_array);
}
free(ws_array[i]);
}
}
for (i=0; i<(int)max_xformats; i++)
{
if (xf_array[i])
free(xf_array[i]);
}
if (numCustomColors)
{
for (i=0; i<numCustomColors; i++)
free(customColors[i]);
free(customColors);
}
if (default_font.str)
free(default_font.str);
if (author.str)
free(author.str);
if (title)
free(title);
if (lastUpdated)
free(lastUpdated);
return 0;
}
void scan_file(COLEDIRENT *cde, void *_info)
{
U32 count = 0;
U16 length=0, target=0, opcode=0, version=0;
U8 buf[16];
COLEFILE *cf;
COLERRNO err;
cf = cole_fopen_direntry(cde, &err);
if (cf == 0)
{ /* error abort processing */
cole_perror (PRGNAME, err);
return;
}
/* Read & process the file... */
while (cole_fread(cf, buf, 1, &err))
{
if (count > 3)
main_line_processor(opcode, version, count-4, target, buf[0]);
else if (count == 0)
{ /* Init everything */
length = 0;
opcode = (U16)buf[0];
target = 80; /* ficticious number */
}
else if (count == 1)
version = (U16)buf[0];
else if (count == 2)
length = (U16)buf[0];
else if (count == 3)
{
length |= (U16)(buf[0]<<8);
target = length;
}
if (count == (U32)(target+3))
count = 0;
else
count++;
if (MaxColExceeded || MaxRowExceeded || MaxWorksheetsExceeded)
break; /* We're outta memory and therefore...done */
}
cole_fclose(cf, &err);
if (Ascii)
{
if (DumpPage)
{ /* Output the XLS Parameters */
int i;
printf("There are %d pages total.\n", sheet_count+1);
for (i=0; i<=sheet_count; i++)
{
printf("Page:%d Name:%s MaxRow:%ld MaxCol:%d\n", i,
ws_array[i]->ws_title.str ? (char *)ws_array[i]->ws_title.str : "(Unknown Page)",
ws_array[i]->biggest_row, ws_array[i]->biggest_col);
}
}
else if (Xtract)
OutputPartialTableAscii();
}
else
{
if (DumpPage)
{ /* Output the XLS Parameters */
int i;
output_header();
printf("<p>There are %d pages total.</p>\n", sheet_count+1);
for (i=0; i<=sheet_count; i++)
{
printf("<p>Page:%d Name:%s MaxRow:%ld MaxCol:%d</p>\n", i,
ws_array[i]->ws_title.str ? (char *)ws_array[i]->ws_title.str : "(Unknown Page)",
ws_array[i]->biggest_row, ws_array[i]->biggest_col);
}
output_footer();
}
else
{
if( OutputXML )
OutputTableXML();
else
OutputTableHTML();
}
}
}
void SetupExtraction(void)
{
if (Xtract)
{ /* Revise the page settings... */
/* printf("-%d %d %d %d %d<br>\n", xp, xr1, xr2, xc1, xc2); */
if ((xp >= first_sheet)&&(xp <= last_sheet)&&(xp <= sheet_count))
{
first_sheet = xp;
last_sheet = xp;
if (xr1 < 0)
{
xr1 = (S16)ws_array[xp]->first_row;
xr2 = (S16)ws_array[xp]->biggest_row;
}
else if ((xr1 >= ws_array[xp]->first_row)&&(xr1 <= ws_array[xp]->biggest_row)
&&(xr2 >= ws_array[xp]->first_row)&&(xr2 <= ws_array[xp]->biggest_row))
{
ws_array[xp]->first_row = xr1;
ws_array[xp]->biggest_row = xr2;
if (xc1 < 0)
{
xc1 = ws_array[xp]->first_col;
xc2 = ws_array[xp]->biggest_col;
}
else if((xc1 >= ws_array[xp]->first_col)&&(xc1 <= ws_array[xp]->biggest_col)
&&(xc2 >= ws_array[xp]->first_col)&&(xc2 <= ws_array[xp]->biggest_col))
{
ws_array[xp]->first_col = xc1;
ws_array[xp]->biggest_col = xc2;
}
else
{
if (Ascii)
fprintf(stderr, "Error - Col not in range during extraction"
" (%d or %d not in [%d..%d])\n", xc1, xc2, ws_array[xp]->first_col, ws_array[xp]->biggest_col);
else
{
printf("Error - Col not in range during extraction.\n");
output_footer();
}
return;
}
}
else
{
if (Ascii)
fprintf(stderr, "Error - Row not in range during extraction"
" (%d or %d not in [%ld..%ld])\n", xr1, xr2, ws_array[xp]->first_row, ws_array[xp]->biggest_row);
else
{
printf("Error - Row not in range during extraction.");
output_footer();
}
return;
}
}
else
{
if (Ascii)
fprintf(stderr, "Error - Page not in range during extraction.");
else
{
printf("Error - Page not in range during extraction.");
output_footer();
}
return;
}
}
}
/*!******************************************************************
* \param count the absolute count in the record
* \param last the size of the record
* \param bufidx the index into the working buffer
* \param buflast the expected length of the working buffer
********************************************************************/
void main_line_processor(U16 opcode, U16 version, U32 count, U16 last, U8 data)
{
U16 cont_opcode = 0;
/* If first pass, reset stuff. */
if (count == 0)
{
if (opcode != 0x3C) /* continue command */
/* {
printf("\n* * * * * * CONTINUE * * * * * * * * *\n\n");
}
else */
{ /* Normal path... */
last_opcode = opcode;
bufidx = 0;
buflast = 0;
cont_str_array = 0;
memset(working_buffer, 0, WBUFF_SIZE);
}
}
if (opcode == 0x3C)
{
opcode = last_opcode;
cont_opcode = 1;
}
/* Abort processing if too big. Next opcode will reset everything. */
if (bufidx >= WBUFF_SIZE)
{
/*printf("OC:%02X C:%04X I:%04X BL:%04X cch:%04X gr:%04X\n", opcode, count, bufidx, buflast, cch, grbit); */
/*abort(); */
return;
}
/* no chart processing for now. */
if (version == 0x0010)
return;
switch (opcode)
{
case 0x09: /* BOF */
working_buffer[bufidx++] = data;
if (bufidx == last)
{
if (file_version == 0)
{ /* File version info can be gathered here...
* 4 = Excel version 4
* 1280 = Excel version 5
* 0500 = Excel 95
* 1536 = Excel 97 */
if (version == 8)
file_version = getShort(&working_buffer[0]);
else
file_version = version;
if (file_version == EXCEL95)
{
use_colors = 0;
HARD_MAX_ROWS = HARD_MAX_ROWS_95;
}
/* printf("Biff:%X\n", file_version); */
}
sheet_count++;
if (sheet_count >= (int)max_worksheets)
add_more_worksheet_ptrs();
}
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 == 8)&&(buflast == 0))
buflast = 8 + getShort(&working_buffer[6]);
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]);
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 links */
if (uni_type == 0)
{
off = 36;
uni_type = 2;
len = getLong(&working_buffer[32]) * 2;
}
else
len = bufidx - off; /* safety measure to make sure it doen't blow up */
}
update_cell_hyperlink(r, c, &working_buffer[off], len, uni_type);
}
break;
case 0x92: /* Color Palette */
working_buffer[bufidx++] = data;
if (bufidx == last)
{ /* This is based on Office 97 info... */
int i;
U8 red, green, blue;
U16 cnt = getShort(&working_buffer[0]);
numCustomColors = cnt;
customColors = (U8 **)calloc(cnt+1, sizeof(char *));
for (i=0; i<cnt; i++)
{
char color_string[8];
red = (unsigned char)working_buffer[(4*i)+2];
green = (unsigned char)working_buffer[(4*i)+3];
blue = (unsigned char)working_buffer[(4*i)+4];
/* printf("%02X%02X%02X\n", (int)red, (int)green, (int)blue); */
sprintf(color_string, "%02X%02X%02X", (int)red, (int)green, (int)blue);
customColors[i] = (U8 *)strdup(color_string);
}
}
break;
case 0x42: /* CodePage */
working_buffer[bufidx++] = data;
if (bufidx == last)
{
CodePage = getShort(&working_buffer[0]);
if (CodePage == 1200)
CodePage = 0; /* Unicode inside, old behavior is OK */
}
break;
default:
break;
}
}
/*! returns 1 on error, 0 on success */
int ws_init(int i)
{
U32 j;
U16 k;
if (i >= (int)max_worksheets)
return 1;
ws_array[i] = (work_sheet *)malloc(sizeof(work_sheet));
if (ws_array[i])
{
ws_array[i]->spanned = 0;
ws_array[i]->first_row = 0;
ws_array[i]->biggest_row = -1;
ws_array[i]->max_rows = ROWS_INCR;
ws_array[i]->first_col = 0;
ws_array[i]->biggest_col = -1;
ws_array[i]->max_cols = COLS_INCR;
uni_string_clear(&ws_array[i]->ws_title);
ws_array[i]->c_array = (cell **)malloc(ROWS_INCR*COLS_INCR*sizeof(cell *));
if (ws_array[i]->c_array == 0)
return 1;
for (j=0; j<ROWS_INCR; j++)
for (k=0; k<COLS_INCR; k++)
ws_array[i]->c_array[(j*ws_array[i]->max_cols)+k] = 0;
}
else
return 1;
return 0;
}
/*! returns 1 on error, 0 on success */
int add_more_worksheet_ptrs(void)
{
work_sheet **tws_array;
int pages;
if (MaxWorksheetsExceeded)
return 1;
if (sheet_count > (int)max_worksheets)
pages = (((sheet_count - max_worksheets)/WORKSHEETS_INCR) + 1) * WORKSHEETS_INCR;
else
pages = WORKSHEETS_INCR;
tws_array = (work_sheet **)realloc(ws_array,
(max_worksheets + pages) * sizeof(work_sheet *));
if (tws_array == NULL)
{
MaxWorksheetsExceeded = 1;
return 1;
}
else
{ /* Next init the array... */
unsigned int i;
ws_array = tws_array;
for (i=max_worksheets; i<max_worksheets+pages; i++)
ws_array[i] = 0;
max_worksheets += pages;
last_sheet = max_worksheets - 1;
}
return 0;
}
int resize_c_array(work_sheet *ws, U32 new_rows, U16 new_cols)
{
cell **tc_array;
if (ws == 0)
return 1;
if (ws->c_array == 0)
return 1;
tc_array = (cell **)malloc((ws->max_rows+new_rows)*(ws->max_cols+new_cols)*sizeof(cell *));
if (tc_array == NULL)
return 1;
else
{
U32 j;
U16 k;
memset(tc_array, 0, (ws->max_rows+new_rows)*(ws->max_cols+new_cols)*sizeof(cell *));
for (j=0; j<(ws->max_rows); j++)
{
for (k=0; k<ws->max_cols; k++)
tc_array[(j*(ws->max_cols+new_cols))+k] = ws->c_array[(j*ws->max_cols)+k];
}
ws->max_cols += new_cols;
ws->max_rows += new_rows;
free(ws->c_array);
ws->c_array = tc_array;
}
return 0;
}
void add_wb_array(U16 r, U16 c, U16 xf, U16 type, U8 uni,
U8 *str, U16 len, U16 crun_cnt, U8 *fmt_run)
{
work_sheet *ws;
if ((sheet_count < 0)||(r > HARD_MAX_ROWS)||(c > HARD_MAX_COLS))
return;
if (sheet_count >= (int)max_worksheets)
{
if (add_more_worksheet_ptrs())
return;
}
if (ws_array[sheet_count] == 0)
{
if (ws_init(sheet_count))
return;
}
ws = ws_array[sheet_count];
if (r >= ws->max_rows)
{
if (MaxRowExceeded)
return;
else
{
int diff = ((r-ws->max_rows)/ROWS_INCR)+1;
if(resize_c_array(ws, ROWS_INCR*diff, 0))
{
MaxRowExceeded = 1;
return;
}
}
}
if (c >= ws->max_cols)
{
if (MaxColExceeded)
return;
else
{
U16 diff = (U16)(((c-ws->max_cols)/COLS_INCR)+1);
if(resize_c_array(ws, 0, (U16)(COLS_INCR*diff)))
{
MaxColExceeded = 1;
return;
}
}
}
if (ws->c_array[(r*ws->max_cols)+c] == 0)
{
if (r > ws_array[sheet_count]->biggest_row)
ws_array[sheet_count]->biggest_row = r;
if (c > ws_array[sheet_count]->biggest_col)
ws_array[sheet_count]->biggest_col = c;
ws->c_array[(r*ws->max_cols)+c] = (cell *)malloc(sizeof(cell));
if (ws->c_array[(r*ws->max_cols)+c])
{
if (str)
{
ws->c_array[(r*ws->max_cols)+c]->ustr.str = (U8 *)malloc(len+1);
if (ws->c_array[(r*ws->max_cols)+c]->ustr.str)
{
memcpy(ws->c_array[(r*ws->max_cols)+c]->ustr.str, str, len);
ws->c_array[(r*ws->max_cols)+c]->ustr.str[len] = 0;
}
ws->c_array[(r*ws->max_cols)+c]->ustr.uni = uni;
ws->c_array[(r*ws->max_cols)+c]->ustr.len = len;
if (fmt_run && crun_cnt)
{
int rlen = crun_cnt*4;
ws->c_array[(r*ws->max_cols)+c]->ustr.fmt_run = malloc(rlen);
if (ws->c_array[(r*ws->max_cols)+c]->ustr.fmt_run)
{
memcpy(ws->c_array[(r*ws->max_cols)+c]->ustr.fmt_run, fmt_run, rlen);
ws->c_array[(r*ws->max_cols)+c]->ustr.crun_cnt = crun_cnt;
}
else
ws->c_array[(r*ws->max_cols)+c]->ustr.crun_cnt = 0;
}
else
{
ws->c_array[(r*ws->max_cols)+c]->ustr.fmt_run = 0;
ws->c_array[(r*ws->max_cols)+c]->ustr.crun_cnt = 0;
}
}
else
uni_string_clear(&ws->c_array[(r*ws->max_cols)+c]->ustr);
ws->c_array[(r*ws->max_cols)+c]->xfmt = xf;
ws->c_array[(r*ws->max_cols)+c]->type = type;
ws->c_array[(r*ws->max_cols)+c]->spanned = 0;
ws->c_array[(r*ws->max_cols)+c]->rowspan = 0;
ws->c_array[(r*ws->max_cols)+c]->colspan = 0;
uni_string_clear(&ws->c_array[(r*ws->max_cols)+c]->h_link);
}
}
else /* Default attributes already copied */
{
if (r > ws_array[sheet_count]->biggest_row)
ws_array[sheet_count]->biggest_row = r;
if (c > ws_array[sheet_count]->biggest_col)
ws_array[sheet_count]->biggest_col = c;
if (str)
{ /* Check if a place holder is there and free it */
if (ws->c_array[(r*ws->max_cols)+c]->ustr.str != 0)
free(ws->c_array[(r*ws->max_cols)+c]->ustr.str);
ws->c_array[(r*ws->max_cols)+c]->ustr.str = (U8 *)malloc(len+1);
if (ws->c_array[(r*ws->max_cols)+c]->ustr.str)
{
memcpy(ws->c_array[(r*ws->max_cols)+c]->ustr.str, str, len);
ws->c_array[(r*ws->max_cols)+c]->ustr.str[len] = 0;
}
ws->c_array[(r*ws->max_cols)+c]->ustr.len = len;
ws->c_array[(r*ws->max_cols)+c]->ustr.uni = uni;
if (fmt_run && crun_cnt)
{
int rlen = crun_cnt*4;
ws->c_array[(r*ws->max_cols)+c]->ustr.fmt_run = malloc(rlen);
if (ws->c_array[(r*ws->max_cols)+c]->ustr.fmt_run)
{
memcpy(ws->c_array[(r*ws->max_cols)+c]->ustr.fmt_run, fmt_run, rlen);
ws->c_array[(r*ws->max_cols)+c]->ustr.crun_cnt = crun_cnt;
}
else
ws->c_array[(r*ws->max_cols)+c]->ustr.crun_cnt = 0;
}
else
{
ws->c_array[(r*ws->max_cols)+c]->ustr.fmt_run = 0;
ws->c_array[(r*ws->max_cols)+c]->ustr.crun_cnt = 0;
}
}
else
{
if (ws->c_array[(r*ws->max_cols)+c]->ustr.str == 0)
{
ws->c_array[(r*ws->max_cols)+c]->ustr.len = 0;
ws->c_array[(r*ws->max_cols)+c]->ustr.uni = 0;
ws->c_array[(r*ws->max_cols)+c]->ustr.fmt_run = 0;
ws->c_array[(r*ws->max_cols)+c]->ustr.crun_cnt = 0;
}
}
ws->c_array[(r*ws->max_cols)+c]->xfmt = xf;
ws->c_array[(r*ws->max_cols)+c]->type = type;
ws->c_array[(r*ws->max_cols)+c]->spanned = 0;
ws->c_array[(r*ws->max_cols)+c]->rowspan = 0;
ws->c_array[(r*ws->max_cols)+c]->colspan = 0;
}
}
void update_cell_xf(U16 r, U16 c, U16 xf)
{
work_sheet *ws;
if ((sheet_count < 0)||(r > HARD_MAX_ROWS)||(c > HARD_MAX_COLS))
return;
if (sheet_count >= (int)max_worksheets)
{
if (add_more_worksheet_ptrs())
return;
}
if (ws_array[sheet_count] == 0)
{
if (ws_init(sheet_count))
return;
}
if (r >= ws_array[sheet_count]->max_rows)
{
if (MaxRowExceeded)
return;
else
{
int diff = ((r-ws_array[sheet_count]->max_rows)/ROWS_INCR)+1;
if(resize_c_array(ws_array[sheet_count], ROWS_INCR*diff, 0))
{
MaxRowExceeded = 1;
return;
}
}
}
if (c >= ws_array[sheet_count]->max_cols)
{
if (MaxColExceeded)
return;
else
{
int diff = ((c-ws_array[sheet_count]->max_cols)/COLS_INCR)+1;
if (resize_c_array(ws_array[sheet_count], 0, (U16)(COLS_INCR*diff)))
{
MaxColExceeded = 1;
return;
}
}
}
ws = ws_array[sheet_count];
if (ws->c_array[(r*ws->max_cols)+c] == 0)
{
ws->c_array[(r*ws->max_cols)+c] = (cell *)malloc(sizeof(cell));
if (ws->c_array[(r*ws->max_cols)+c])
{
uni_string_clear(&ws->c_array[(r*ws->max_cols)+c]->ustr);
ws->c_array[(r*ws->max_cols)+c]->xfmt = xf;
ws->c_array[(r*ws->max_cols)+c]->type = 1; /* This is the Blank Cell type */
if (r > ws_array[sheet_count]->biggest_row)
ws_array[sheet_count]->biggest_row = r;
if (c > ws_array[sheet_count]->biggest_col)
ws_array[sheet_count]->biggest_col = c;
ws->c_array[(r*ws->max_cols)+c]->spanned = 0;
ws->c_array[(r*ws->max_cols)+c]->rowspan = 0;
ws->c_array[(r*ws->max_cols)+c]->colspan = 0;
uni_string_clear(&ws->c_array[(r*ws->max_cols)+c]->h_link);
}
}
/* else
{
printf("R:%02X C:%02X XF:%02X is:%02X\n",
r, c, xf, ws->c_array[r][c]->xfmt);
} */
}
void update_cell_hyperlink(U16 r, U16 c, U8 *hyperlink, int len, U16 uni)
{
work_sheet *ws;
if (sheet_count < 0) /* Used to do a "0 <" check on r & c */
return;
if (sheet_count >= (int)max_worksheets)
{
if (add_more_worksheet_ptrs())
return;
}
if (ws_array[sheet_count] == 0)
{
if (ws_init(sheet_count))
return;
}
if (r >= ws_array[sheet_count]->max_rows)
{
if (MaxRowExceeded)
return;
else
{
int diff = ((r-ws_array[sheet_count]->max_rows)/ROWS_INCR)+1;
if(resize_c_array(ws_array[sheet_count], ROWS_INCR*diff, 0))
{
MaxRowExceeded = 1;
return;
}
}
}
if (c >= ws_array[sheet_count]->max_cols)
{
if (MaxColExceeded)
return;
else
{
int diff = ((c-ws_array[sheet_count]->max_cols)/COLS_INCR)+1;
if(resize_c_array(ws_array[sheet_count], 0, (U16)(COLS_INCR*diff)))
{
MaxColExceeded = 1;
return;
}
}
}
ws = ws_array[sheet_count];
if (ws->c_array[(r*ws->max_cols)+c] == 0)
{ /* should not get here, but just in case */
return;
}
if (ws->c_array[(r*ws->max_cols)+c]->h_link.str == 0)
{
ws->c_array[(r*ws->max_cols)+c]->h_link.str = (U8 *)malloc(len);
if (ws->c_array[(r*ws->max_cols)+c]->h_link.str)
memcpy(ws->c_array[(r*ws->max_cols)+c]->h_link.str, hyperlink, len);
ws->c_array[(r*ws->max_cols)+c]->h_link.uni = uni;
if (len)
{
if (uni < 2)
ws->c_array[(r*ws->max_cols)+c]->h_link.len = (U16)(len-1);
else
ws->c_array[(r*ws->max_cols)+c]->h_link.len = (U16)(len-2);
}
}
/* else
{
printf("R:%02X C:%02X XF:%02X is:%s\n",
r, c, xf, ws->c_array[r][c]->h_link.str);
} */
}
void add_str_array(U8 uni, U8 *str, U16 len, U8 *fmt_run, U8 crun_cnt)
{
if ((str == 0)||(len == 0))
{
next_string++; /* increment for empty strings, too */
return;
}
if (next_string >= max_strings)
{
uni_string **tstr_array;
size_t new_size = (max_strings + STRINGS_INCR) * sizeof(uni_string *);
tstr_array = (uni_string **)realloc(str_array, new_size);
if (tstr_array == NULL)
{
MaxStringsExceeded = 1;
/* fprintf(stderr, "%s: cannot allocate %d bytes for string storage %d: %s",
PRGNAME, new_size, errno, strerror(errno)); */
return;
}
else
{
unsigned long i;
str_array = tstr_array;
/* Clear the new string slots */
for (i=max_strings; i<(max_strings + STRINGS_INCR); i++)
str_array[i] = 0;
max_strings += STRINGS_INCR;
}
}
if (str_array[next_string] == 0)
{
str_array[next_string] = (uni_string *)malloc(sizeof(uni_string));
if (str_array[next_string])
{
str_array[next_string]->str = (U8 *)malloc(len+1);
if (str_array[next_string]->str)
{
memcpy(str_array[next_string]->str, str, len);
str_array[next_string]->str[len] = 0;
str_array[next_string]->len = len;
str_array[next_string]->uni = uni;
if (fmt_run && crun_cnt)
{
int rlen = crun_cnt*4;
str_array[next_string]->fmt_run = malloc(rlen);
if (str_array[next_string]->fmt_run)
{
memcpy(str_array[next_string]->fmt_run, fmt_run, rlen);
str_array[next_string]->crun_cnt = crun_cnt;
}
else
str_array[next_string]->crun_cnt = 0;
}
else
{
str_array[next_string]->fmt_run = 0;
str_array[next_string]->crun_cnt = 0;
}
}
}
}
next_string++;
}
void add_font(U16 size, U16 attr, U16 c_idx, U16 bold, U16 super, U8 underline,
U16 uni, U8 *n, U16 len)
{
if (n == 0)
return;
if (next_font >= max_fonts)
{
font_attr **tfont_array;
fnt_cnt *tf_cnt;
tfont_array = (font_attr **)realloc(font_array, (max_fonts * FONTS_INCR) * sizeof(font_attr *));
tf_cnt = (fnt_cnt *)realloc(f_cnt, (max_fonts * FONTS_INCR) * sizeof(fnt_cnt));
if ((tf_cnt == NULL) || (tfont_array == NULL))
{
MaxFontsExceeded = 1;
return;
}
else
{ /* Next init the array... */
unsigned int i;
font_array = tfont_array;
f_cnt = tf_cnt;
for (i=max_fonts; i<max_fonts+FONTS_INCR; i++)
{
font_array[i] = 0;
f_cnt[i].name = 0;
}
max_fonts += FONTS_INCR;
}
}
if (font_array[next_font] == 0)
{
font_array[next_font] = (font_attr *)malloc(sizeof(font_attr));
if (font_array[next_font])
{
font_array[next_font]->name.str = (U8 *)malloc(len+1);
if (font_array[next_font]->name.str)
{
font_array[next_font]->attr = attr;
font_array[next_font]->c_idx = c_idx;
font_array[next_font]->bold = bold;
font_array[next_font]->super = super;
font_array[next_font]->underline = underline;
font_array[next_font]->name.uni = uni;
memcpy(font_array[next_font]->name.str, n, len);
font_array[next_font]->name.str[len] = 0;
font_array[next_font]->name.len = len;
font_array[next_font]->name.fmt_run = 0;
font_array[next_font]->name.crun_cnt = 0;
/* We will "pre-digest" the font size.. */
if (size >= 0x02D0) /* 36 pts */
font_array[next_font]->size = 7;
else if (size >= 0x01E0) /* 24 pts */
font_array[next_font]->size = 6;
else if (size >= 0x0168) /* 18 pts */
font_array[next_font]->size = 5;
else if (size >= 0x00F0) /* 12 pts */
font_array[next_font]->size = 4;
else if (size >= 0x00C8) /* 10 pts */
font_array[next_font]->size = 3;
else if (size >= 0x00A0) /* 8 pts */
font_array[next_font]->size = 2;
else
font_array[next_font]->size = 1;
}
}
}
next_font++;
if (next_font == 4) /* Per the doc's - number 4 doesn't exist. */
next_font++;
}
void add_ws_title(U16 uni, U8 *n, U16 len)
{
if (n == 0)
return;
if (next_ws_title >= max_worksheets)
{
if (add_more_worksheet_ptrs())
return;
}
if (ws_array[next_ws_title] == 0)
{
if (ws_init(next_ws_title))
return;
}
if (ws_array[next_ws_title]->ws_title.str == 0)
{
ws_array[next_ws_title]->ws_title.str = (U8 *)malloc(len+1);
if (ws_array[next_ws_title]->ws_title.str)
{
ws_array[next_ws_title]->ws_title.uni = uni;
memcpy(ws_array[next_ws_title]->ws_title.str, n, len);
ws_array[next_ws_title]->ws_title.str[len] = 0;
ws_array[next_ws_title]->ws_title.len = len;
ws_array[next_ws_title]->ws_title.crun_cnt = 0;
ws_array[next_ws_title]->ws_title.fmt_run = 0;
}
}
next_ws_title++;
}
void add_xf_array(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)
{
if (next_xf >= max_xformats)
{
xf_attr **txf_array;
txf_array = (xf_attr **)realloc(xf_array, (max_xformats + XFORMATS_INCR) * sizeof(xf_attr *));
if (txf_array == NULL)
{
MaxXFExceeded = 1;
return;
}
else
{
unsigned int i;
xf_array = txf_array;
for (i=max_xformats; i<(max_xformats + XFORMATS_INCR); i++)
xf_array[i] = 0;
max_xformats += XFORMATS_INCR;
}
}
if (xf_array[next_xf] == 0)
{
xf_array[next_xf] = (xf_attr *)malloc(sizeof(xf_attr));
if (xf_array[next_xf])
{
xf_array[next_xf]->fnt_idx = fnt_idx;
xf_array[next_xf]->fmt_idx = fmt_idx;
xf_array[next_xf]->gen = gen;
xf_array[next_xf]->align = align;
xf_array[next_xf]->indent = indent;
xf_array[next_xf]->b_style = b_style;
xf_array[next_xf]->b_l_color = b_l_color;
xf_array[next_xf]->b_t_color = b_t_color;
xf_array[next_xf]->cell_color = cell_color;
}
next_xf++;
}
}
void decodeBoolErr(U16 value, U16 flag, char *str)
{
if (str == 0)
return;
if (flag == 0)
{
if (value == 1)
strcpy(str, "TRUE");
else
strcpy(str, "FALSE");
}
else
{
switch(value)
{
case 0x00:
strcpy(str, "#NULL!");
break;
case 0x07:
strcpy(str, "#DIV/0!");
break;
case 0x0F:
strcpy(str, "#VALUE!");
break;
case 0x17:
strcpy(str, "#REF!");
break;
case 0x1D:
strcpy(str, "#NAME?");
break;
case 0x24:
strcpy(str, "#NUM!");
break;
case 0x2A:
strcpy(str, "#N/A");
break;
default:
strcpy(str, "#ERR");
break;
}
}
}
int IsCellNumeric(cell *c)
{
int ret_val = 0;
switch (c->type & 0x00FF)
{
case 0x02: /* Int */
case 0x03: /* Float */
/* case 0x06: */ /* Formula */
/* case 0x08: */
case 0x7E: /* RK */
/* case 0xBC: */
/* case 0x21: */
case 0xBD: /* MulRK */
ret_val = 1;
break;
default:
break;
}
return ret_val;
}
/*! \retval 0 not safe at all.
\retval 1 extended format is OK
\retval 2 Fonts OK */
int IsCellSafe(cell *c)
{
int safe = 0;
if (c->xfmt < next_xf)
{
if (xf_array[c->xfmt])
{
safe = 1;
if (xf_array[c->xfmt]->fnt_idx < next_font)
{
if (font_array[xf_array[c->xfmt]->fnt_idx])
safe = 2;
}
}
}
return safe;
}
int IsCellFormula(cell *c)
{
if ((c->type > 0x0100)||(c->type == 0x0006))
return 1;
else
return 0;
}
void output_cell(cell *c, int xml)
{
html_attr h;
if (c == NULL)
printf( xml ? "" : "<TD>&nbsp;");
else if (c->spanned != 0)
return;
else
{ /* Determine whether or not its of numeric origin.. */
int numeric = IsCellNumeric(c); /* 0=Text 1=Numeric */
html_flag_init(&h);
if (c->xfmt == 0)
{ /* Unknown format... */
printf( xml ? "" : "<TD>"); /* This section doesn't use Unicode */
if (c->ustr.str)
OutputString(&(c->ustr));
else
printf( xml ? "" : "&nbsp;");
}
else
{ /* This is the BIFF7 & 8 stuff... */
int safe;
int nullString = 1;
safe = IsCellSafe(c);
if (c->ustr.str)
{
if (c->ustr.uni < 2) /* UNI? */
nullString = null_string(c->ustr.str);
else
nullString = 0;
}
/* First take care of text color & alignment */
printf( xml ? "" : "<TD");
if ((c->rowspan != 0)||(c->colspan != 0))
{
if (c->colspan)
printf( xml ? "<colspan>%d</colspan>" : " COLSPAN=\"%d\"", c->colspan);
if (c->rowspan)
printf( xml ? "<rowspan>%d</rowspan>" : " ROWSPAN=\"%d\"", c->rowspan);
}
if ((safe > 0)&&(!nullString))
{
switch(xf_array[c->xfmt]->align & 0x0007)
{ /* Override default table alignment when needed */
case 2:
case 6: /* Center across selection */
if (strcmp(default_alignment, "center") != 0)
printf( xml ? "" : " ALIGN=\"center\"");
break;
case 0: /* General alignment */
if (numeric) /* Numbers */
{
if (strcmp(default_alignment, "right") != 0)
printf( xml ? "" : " ALIGN=\"right\"");
}
else if ((c->type & 0x00FF) == 0x05)
{ /* Boolean */
if (strcmp(default_alignment, "center") != 0)
printf( xml ? "" : " ALIGN=\"center\"");
}
else
{
if (strcmp(default_alignment, "left") != 0)
printf( xml ? "" : " ALIGN=\"left\"");
}
break;
case 3:
if (strcmp(default_alignment, "right") != 0)
printf( xml ? "" : " ALIGN=\"right\"");
break;
case 1:
default:
if (strcmp(default_alignment, "left") != 0)
printf( xml ? "" : " ALIGN=\"left\"");
break;
}
switch((xf_array[c->xfmt]->align & 0x0070)>>4)
{
case 0:
printf( xml ? "" : " VALIGN=\"top\"");
break;
case 1:
printf( xml ? "" : " VALIGN=\"center\"");
break;
case 2: /* General alignment */
if (safe > 1)
{
if ((font_array[xf_array[c->xfmt]->fnt_idx]->super & 0x0003) == 0x0001)
printf( xml ? "" : " VALIGN=\"top\""); /* Superscript */
}
break;
default:
if (safe > 1)
{
if ((font_array[xf_array[c->xfmt]->fnt_idx]->super & 0x0003) == 0x0001)
printf( xml ? "" : " VALIGN=\"top\""); /* Superscript */
}
break;
}
}
/* Next do the bgcolor... BGCOLOR="" */
if (safe && use_colors)
{
int fgcolor;
/* int bgcolor = (xf_array[c->xfmt]->cell_color & 0x3F80) >> 7; */
fgcolor = (xf_array[c->xfmt]->cell_color & 0x007F);
/* printf(" XF:%X BG Color:%d, FG Color:%d", c->xfmt, bgcolor, fgcolor); */
/* Might be better by blending bg & fg colors?
If valid, fgcolor != black and fgcolor != white */
if( ! xml )
{
if (numCustomColors)
{
if (fgcolor < numCustomColors)
{
if (strcmp(default_background_color, (char *)customColors[fgcolor-8]) != 0)
printf(" BGCOLOR=\"%s\"", customColors[fgcolor-8]);
}
}
else
{
if (fgcolor < MAX_COLORS)
{
if (strcmp(default_background_color, colorTab[fgcolor]) != 0)
printf(" BGCOLOR=\"%s\"", colorTab[fgcolor]);
}
}
}
}
/* Next set the border color... */
if (safe && use_colors)
{
int lcolor, rcolor, tcolor, bcolor;
lcolor = xf_array[c->xfmt]->b_l_color & 0x007F;
rcolor = (xf_array[c->xfmt]->b_l_color & 0x3F80) >> 7;
tcolor = xf_array[c->xfmt]->b_t_color & 0x007F;
bcolor = (xf_array[c->xfmt]->b_t_color & 0x3F80) >> 7;
if (((lcolor & rcolor & tcolor & bcolor) == lcolor)&&(lcolor < MAX_COLORS))
{ /* if they are all the same...do it...that is if its different from BLACK */
if (numCustomColors == 0) /* Don't do custom borders */
{
if ((strcmp(colorTab[lcolor], "000000") != 0)&&(strcmp(colorTab[lcolor], "FFFFFF") != 0))
{
if( !xml )
printf(" BORDERCOLOR=\"%s\"", colorTab[lcolor]);
}
}
}
}
/* Close up the <TD>... */
printf(xml ? "" : ">");
/* Next set font properties */
if (safe > 1 && !xml )
{
if (!nullString)
output_start_font_attribute(&h, xf_array[c->xfmt]->fnt_idx);
}
/* Finally, take care of font modifications */
if ((safe > 1)&&(!nullString))
{
if ((font_array[xf_array[c->xfmt]->fnt_idx]->underline&0x0023) > 0)
{
if (c->h_link.str)
{
printf("<A href=\"");
if (c->h_link.uni)
{
if (memchr((char *)c->h_link.str, ':', c->h_link.len) == 0)
{
if (memchr((char *)c->h_link.str, '@', c->h_link.len))
printf("mailto:");
}
}
OutputString(&(c->h_link));
printf("\">");
h.uflag = 2;
}
else
{
printf("<U>");
h.uflag = 1;
}
}
output_start_html_attr(&h, xf_array[c->xfmt]->fnt_idx, 0);
}
if (c->ustr.str)
{
if (safe)
output_formatted_data(&(c->ustr), xf_array[c->xfmt]->fmt_idx, numeric, IsCellFormula(c));
else
OutputString(&(c->ustr));
}
else
printf( xml ? "" : "&nbsp;");
/* printf(" T:%02X", c->type & 0x00FF); */
}
/* Now close the tags... */
output_end_html_attr(&h);
if (h.fflag)
printf("</FONT>");
}
if (!aggressive)
printf( xml ? "" : "</TD>\n");
}
void output_formatted_data(uni_string *u, U16 idx, int numeric, int formula)
{
if ((idx < max_xformats)&&(u->str))
{
if ((formula_warnings)&&(formula))
{
if( OutputXML )
printf( "<NotAccurate/>" );
else
printf("** ");
notAccurate++;
}
if (numeric)
{
int year, month, date;
long num;
F64 dnum;
int hr, minu, sec, msec;
/* printf("idx:%d ", idx); */
switch (idx)
{
case 0x00: /* General */
dnum = atof((char *)u->str);
printf("%.15g", dnum);
break;
case 0x01: /* Number 0 */
dnum = atof((char *)u->str);
printf("%.0f", dnum);
break;
case 0x02: /* Number 0.00 */
dnum = atof((char *)u->str);
printf("%.2f", dnum);
break;
case 0x03: /* Number w/comma 0,000 */
PrintFloatComma("%.0f", 0, (F64)atof((char *)u->str));
break;
case 0x04: /* Number w/comma 0,000.00 */
PrintFloatComma("%.2f", 0, (F64)atof((char *)u->str));
break;
case 0x05: /* Currency, no decimal */
PrintFloatComma("%.0f", 1, (F64)atof((char *)u->str));
break;
case 0x06: /* Currency, no decimal Red on Neg */
PrintFloatComma("%.0f", 1, (F64)atof((char *)u->str));
break;
case 0x07: /* Currency with decimal */
PrintFloatComma("%.2f", 1, (F64)atof((char *)u->str));
break;
case 0x08: /* Currency with decimal Red on Neg */
PrintFloatComma("%.2f", 1, (F64)atof((char *)u->str));
break;
case 0x09: /* Percent 0% */
if (Csv)
printf("\"");
dnum = 100.0*atof((char *)u->str);
printf("%.0f%%", dnum);
if (Csv)
printf("\"");
break;
case 0x0A: /* Percent 0.00% */
if (Csv)
printf("\"");
dnum = 100.0*atof((char *)u->str);
printf("%.2f%%", dnum);
if (Csv)
printf("\"");
break;
case 0x0B: /* Scientific 0.00+E00 */
if (Csv)
printf("\"");
dnum = atof((char *)u->str);
printf("%.2E", dnum);
if (Csv)
printf("\"");
break;
case 0x0C: /* Fraction 1 number e.g. 1/2, 1/3 */
if (Csv)
printf("\"");
dnum = atof((char *)u->str);
print_as_fraction(dnum, 1);
if (Csv)
printf("\"");
break;
case 0x0D: /* Fraction 2 numbers e.g. 1/50, 25/33 */
if (Csv)
printf("\"");
dnum = atof((char *)u->str);
print_as_fraction(dnum, 2);
if (Csv)
printf("\"");
break;
case 0x0E: /* Date: m-d-y */
if (Csv)
printf("\"");
num = atol((char *)u->str);
NumToDate(num, &year, &month, &date);
printf("%d-%d-%02d", month, date, year);
if (Csv)
printf("\"");
break;
case 0x0F: /* Date: d-mmm-yy */
if (Csv)
printf("\"");
num = atol((char *)u->str);
NumToDate(num, &year, &month, &date);
printf("%d-%s-%02d", date, month_abbr[month-1], year);
if (Csv)
printf("\"");
break;
case 0x10: /* Date: d-mmm */
if (Csv)
printf("\"");
num = atol((char *)u->str);
NumToDate(num, &year, &month, &date);
printf("%d-%s", date, month_abbr[month-1]);
if (Csv)
printf("\"");
break;
case 0x11: /* Date: mmm-yy */
if (Csv)
printf("\"");
num = atol((char *)u->str);
NumToDate(num, &year, &month, &date);
printf("%s-%02d", month_abbr[month-1], year);
if (Csv)
printf("\"");
break;
case 0x12: /* Time: h:mm AM/PM */
if (Csv)
printf("\"");
FracToTime(u->str, &hr, &minu, 0, 0);
if (hr == 0)
printf("12:%02d AM", minu);
else if (hr < 12)
printf("%d:%02d AM", hr, minu);
else if (hr == 12)
printf("12:%02d PM", minu);
else
printf("%d:%02d PM", hr-12, minu);
if (Csv)
printf("\"");
break;
case 0x13: /* Time: h:mm:ss AM/PM */
if (Csv)
printf("\"");
FracToTime(u->str, &hr, &minu, &sec, 0);
if (hr == 0)
printf("12:%02d:%02d AM", minu, sec);
else if (hr < 12)
printf("%d:%02d:%02d AM", hr, minu, sec);
else if (hr == 12)
printf("12:%02d:%02d PM", minu, sec);
else
printf("%d:%02d:%02d PM", hr-12, minu, sec);
if (Csv)
printf("\"");
break;
case 0x14: /* Time: h:mm */
if (Csv)
printf("\"");
FracToTime(u->str, &hr, &minu, 0, 0);
printf("%d:%02d", hr, minu);
if (Csv)
printf("\"");
break;
case 0x15: /* Time: h:mm:ss */
if (Csv)
printf("\"");
FracToTime(u->str, &hr, &minu, &sec, 0);
if ((hr != 0)||(minu != 0)||(sec != 0))
printf("%d:%02d:%02d", hr, minu, sec);
else
{
if (Ascii)
putchar(' ');
else
printf(OutputXML ? "" : "&nbsp;");
}
if (Csv)
printf("\"");
break;
case 0x25: /* Number with comma, no decimal */
if (Csv)
printf("\"");
PrintFloatComma("%.0f", 0, (F64)atof((char *)u->str));
if (Csv)
printf("\"");
break;
case 0x26: /* Number with comma, no decimal, red on negative */
if (Csv)
printf("\"");
PrintFloatComma("%.0f", 0, (F64)atof((char *)u->str));
if (Csv)
printf("\"");
break;
case 0x27: /* Number with comma & decimal */
if (Csv)
printf("\"");
PrintFloatComma("%.2f", 0, (F64)atof((char *)u->str));
if (Csv)
printf("\"");
break;
case 0x28: /* Number with comma & decimal, red on negative */
if (Csv)
printf("\"");
PrintFloatComma("%.2f", 0, (F64)atof((char *)u->str));
if (Csv)
printf("\"");
break;
case 0x29: /* Number with comma, no decimal */
if (Csv)
printf("\"");
PrintFloatComma("%.2f", 0, (F64)atof((char *)u->str));
if (Csv)
printf("\"");
break;
case 0x2a: /* Currency, no decimal */
if (Csv)
printf("\"");
PrintFloatComma("%.0f", 1, (F64)atof((char *)u->str));
if (Csv)
printf("\"");
break;
case 0x2B: /* Number w/comma & decimal 0,000.00 */
if (Csv)
printf("\"");
PrintFloatComma("%.2f", 0, (F64)atof((char *)u->str));
if (Csv)
printf("\"");
break;
case 0x2C: /* Accounting Currency $0,000.00 */
{
F64 acc_val = atof((char *)u->str);
if (Csv)
printf("\"");
if (acc_val < 0.0)
PrintFloatComma(" (%.2f)", 1, fabs(acc_val));
else
PrintFloatComma(" %.2f", 1, acc_val);
if (Csv)
printf("\"");
break;
}
case 0x2D: /* Time: mm:ss */
if (Csv)
printf("\"");
FracToTime(u->str, &hr, &minu, &sec, 0);
printf("%02d:%02d", minu, sec);
if (Csv)
printf("\"");
break;
case 0x2E: /* Time: [h]:mm:ss */
if (Csv)
printf("\"");
FracToTime(u->str, &hr, &minu, &sec, 0);
if (hr)
printf("%d:%02d:%02d", hr, minu, sec);
else
printf("%02d:%02d", minu, sec);
if (Csv)
printf("\"");
break;
case 0x2F: /* Time: mm:ss.0 */
if (Csv)
printf("\"");
FracToTime(u->str, &hr, &minu, &sec, &msec);
printf("%02d:%02d.%01d", minu, sec, msec);
if (Csv)
printf("\"");
break;
case 0x31: /* Text - if we are here...its a number */
dnum = atof((char *)u->str);
printf("%g", dnum);
break;
default: /* Unsupported...but, if we are here, its a number */
{
char *ptr = strchr((char *)u->str, '.');
if( OutputXML )
printf( "<NoFormat/>" );
dnum = atof((char *)u->str);
if (ptr)
{
if (Csv)
printf("\"%.15g\"", dnum );
else if (OutputXML)
printf("%.15g", dnum );
else
printf("%.15g *", dnum );
}
else
{
num = atol((char *)u->str);
if (Csv)
printf("%ld", num);
else if (OutputXML)
printf("%ld", num );
else
printf("%ld *", num );
}
/* printf(" F:%02X", idx); */
NoFormat++ ;
}
break;
}
}
else /* Text data */
OutputString(u);
}
else /* Error handling just dump it. */
OutputString(u);
}
void PrintFloatComma(char *fformat, int is_currency, F64 d)
{
int len, int_len, dec_len;
char *ptr2, buf[64];
sprintf(buf, fformat, fabs(d));
len = strlen(buf);
ptr2 = strchr(buf, '.');
if (ptr2)
{
int_len = ptr2 - buf;
dec_len = len - int_len;
if (isdigit(buf[0]) == 0)
{
char *ptr = &buf[0];
while (isdigit(*ptr) == 0)
{
int_len--;
ptr++;
if (*ptr == 0)
break;
}
}
}
else
{
int_len = len;
dec_len = 0;
}
if (int_len > 3)
{ /* we have to do it the hard way... */
char rbuf[64], buf2[64];
int neg, i, j, count=0;
if (d < 0.0)
neg = 1;
else
neg = 0;
/* reverse the string. Its easier to work this way. */
for (i=0, j=len-1; i<len;i++, j--)
rbuf[i] = buf[j];
rbuf[len] = 0;
if (ptr2)
{
memcpy(buf2, rbuf, dec_len);
i = dec_len;
j = dec_len;
}
else
{
i = 0;
j = 0;
}
for ( ;i<len;i++, j++)
{
buf2[j] = rbuf[i];
count++;
if ((count%3)==0)
{
if (isdigit(rbuf[i+1]))
buf2[++j] = ',';
}
}
if (neg)
buf2[j++] = '-';
if (is_currency)
buf2[j++] = (char)currency_symbol;
buf2[j] = 0;
len = strlen(buf2);
for (i=0, j=len-1; i<len;i++, j--)
buf[i] = buf2[j];
buf[len] = 0;
if (Csv)
printf("\"%s\"", buf);
else
printf("%s", buf);
}
else /* too short for commas, just output it as is. */
{
if (is_currency)
putchar((char)currency_symbol);
printf(fformat, d);
}
}
void print_as_fraction(F64 d, int digits)
{
F64 i, j, w, r, closest=1.0, lim = 9.0;
int ci=1, cj=1;
/* Take care of negative sign */
if (digits == 2)
lim = 99.0;
if (d < 0)
putchar('-');
/** take care of whole number part */
w = fabs(d);
if (w >= 1.0)
{
int n = (int)w;
printf("%d ", n);
r = w - (F64)n;
}
else
r = w;
/* Get closest fraction - brute force */
for (j=lim; j>0.0; j--)
{
for (i=lim; i>=0.0; i--)
{
if ( fabs((i/j)-r) <= closest)
{
closest = fabs((i/j)-r);
ci = (int)i;
cj = (int)j;
}
}
}
/* Done, print it... */
if (ci != 0)
printf("%d/%d", ci, cj);
}
void trim_sheet_edges(unsigned int sheet)
{
cell *ce;
int not_done = 1;
S32 r;
U16 c;
if ((sheet >= max_worksheets)||(ws_array[sheet] == 0)||
(trim_edges == 0)||(ws_array[sheet]->spanned))
return;
if (ws_array[sheet]->c_array == 0)
return;
if ( (ws_array[sheet]->biggest_row == -1) ||
(ws_array[sheet]->biggest_col == -1) )
return;
/* First find top edge */
for (r=ws_array[sheet]->first_row; r<=ws_array[sheet]->biggest_row; r++)
{
for (c=ws_array[sheet]->first_col; c<=ws_array[sheet]->biggest_col; c++)
{ /* This stuff happens for each cell... */
ce = ws_array[sheet]->c_array[(r*ws_array[sheet]->max_cols)+c];
if (ce)
{
if (ce->ustr.str)
{
if (!null_string(ce->ustr.str))
{
not_done = 0;
break;
}
}
}
}
if (!not_done)
break;
}
if (not_done)
ws_array[sheet]->first_row = ws_array[sheet]->biggest_row;
else
ws_array[sheet]->first_row = r;
/* Second Find bottom edge */
not_done = 1;
for (r=ws_array[sheet]->biggest_row; r>(S32)ws_array[sheet]->first_row; r--)
{
for (c=ws_array[sheet]->first_col; c<=ws_array[sheet]->biggest_col; c++)
{ /* This stuff happens for each cell... */
ce = ws_array[sheet]->c_array[(r*ws_array[sheet]->max_cols)+c];
if (ce)
{
if (ce->ustr.str)
{
if (!null_string(ce->ustr.str))
{
not_done = 0;
break;
}
}
}
}
if (!not_done)
break;
}
ws_array[sheet]->biggest_row = r;
/* Third find left edge */
not_done = 1;
for (c=ws_array[sheet]->first_col; c<=ws_array[sheet]->biggest_col; c++)
{
for (r=ws_array[sheet]->first_row; r<=ws_array[sheet]->biggest_row; r++)
{ /* This stuff happens for each cell... */
ce = ws_array[sheet]->c_array[(r*ws_array[sheet]->max_cols)+c];
if (ce)
{
if (ce->ustr.str)
{
if (!null_string(ce->ustr.str))
{
not_done = 0;
break;
}
}
}
}
if (!not_done)
break;
}
if (not_done)
ws_array[sheet]->first_col = ws_array[sheet]->biggest_col;
else
ws_array[sheet]->first_col = c;
/* Last, find right edge */
not_done = 1;
for (c=ws_array[sheet]->biggest_col; c>ws_array[sheet]->first_col; c--)
{
for (r=ws_array[sheet]->first_row; r<=ws_array[sheet]->biggest_row; r++)
{ /* This stuff happens for each cell... */
ce = ws_array[sheet]->c_array[(r*ws_array[sheet]->max_cols)+c];
if (ce)
{
if (ce->ustr.str)
{
if (!null_string(ce->ustr.str))
{
not_done = 0;
break;
}
}
}
}
if (!not_done)
break;
}
ws_array[sheet]->biggest_col = c;
}
/***************
*! Figures out the best font & alignment for the current table.
* Also sets the default_font and default_alignment.
****************/
void update_default_font(unsigned int sheet)
{
cell *ce;
int r, c, f;
if ((sheet >= max_worksheets)||(ws_array[sheet] == 0))
return;
if (ws_array[sheet]->c_array == 0)
return;
/* Clear the book-keeping info... */
for (r=0; r<FONTS_INCR; r++)
{
f_cnt[r].cnt = 0;
if (f_cnt[r].name)
{
if (f_cnt[r].name->str)
free(f_cnt[r].name->str);
free(f_cnt[r].name);
f_cnt[r].name = 0;
}
}
if (default_font.str)
free(default_font.str);
for (r=0; r<7; r++)
fnt_size_cnt[r] = 0;
/* Now check each cell to see what its using. */
for (r=ws_array[sheet]->first_row; r<=ws_array[sheet]->biggest_row; r++)
{
for (c=ws_array[sheet]->first_col; c<=ws_array[sheet]->biggest_col; c++)
{ /* This stuff happens for each cell... */
ce = ws_array[sheet]->c_array[(r*ws_array[sheet]->max_cols)+c];
if (ce)
{
if ((ce->xfmt < next_xf)&&(ce->ustr.str))
{
if (strcmp((char *)ce->ustr.str, "&nbsp;"))
{
if (ce->xfmt < next_xf)
{
if (xf_array[ce->xfmt])
{
unsigned int fn = xf_array[ce->xfmt]->fnt_idx;
if (fn < next_font)
{
if (font_array[fn])
{
if (font_array[fn]->name.str)
{
/* Here's where we check & increment count... */
incr_f_cnt(&(font_array[fn]->name));
if ((font_array[fn]->size < 8)&&(font_array[fn]->size))
fnt_size_cnt[font_array[fn]->size-1]++;
}
}
}
}
}
}
}
}
}
}
f = get_default_font();
if (f == -1)
{
default_font.str = (U8 *)malloc(6);
if (default_font.str)
{
strcpy((char *)default_font.str, "Arial");
default_font.uni = 0;
default_font.len = 5;
}
}
else
{
default_font.str = (U8 *)malloc(f_cnt[f].name->len+1);
if (default_font.str)
{
memcpy(default_font.str, f_cnt[f].name->str, f_cnt[f].name->len);
default_font.str[f_cnt[f].name->len] = 0;
default_font.uni = f_cnt[f].name->uni;
default_font.len = f_cnt[f].name->len;
}
}
/* Find the font size with the most counts...
Just re-using variables, c - max cnt, f = position of max cnt */
c = 0;
f = 3;
for (r=0; r<7; r++)
{
if (fnt_size_cnt[r] > c)
{
c = fnt_size_cnt[r];
f = r;
}
}
if (fnt_size_cnt[2] == c) /* favor size 3... */
default_fontsize = 3;
else
default_fontsize = f+1;
for (r=0; r<FONTS_INCR; r++)
{
if (f_cnt[r].name != 0)
{
if (f_cnt[r].name->str != 0)
free(f_cnt[r].name->str);
free(f_cnt[r].name);
f_cnt[r].name= 0;
}
}
}
void incr_f_cnt(uni_string *name)
{
int i;
if ((name == 0)||(name->str == 0)||(name->str[0] == 0))
return;
for (i=0; i<FONTS_INCR; i++)
{
if (f_cnt[i].name)
{
if (uni_string_comp(name, f_cnt[i].name) == 0)
f_cnt[i].cnt++;
}
else
{
f_cnt[i].name = (uni_string *)malloc(sizeof(uni_string));
if (f_cnt[i].name)
{
f_cnt[i].name->str = (U8 *)malloc(name->len+1);
if (f_cnt[i].name->str)
{
memcpy(f_cnt[i].name->str, name->str, name->len);
f_cnt[i].name->str[name->len] = 0;
f_cnt[i].name->uni = name->uni;
f_cnt[i].name->len = name->len;
f_cnt[i].cnt = 1;
break;
}
}
}
}
}
int get_default_font(void)
{
int i, m = -1;
for (i=0; i<FONTS_INCR; i++)
{
if (f_cnt[i].name)
{
if (f_cnt[i].name->str)
{
if (f_cnt[i].cnt > m)
m = i;
}
}
}
return m;
}
void update_default_alignment(unsigned int sheet, int row)
{
int i, left = 0, center = 0, right = 0;
cell *c;
if ((sheet >= max_worksheets)||(ws_array[sheet] == 0))
return;
if (ws_array[sheet]->c_array == 0)
return;
for (i=ws_array[sheet]->first_col; i<=ws_array[sheet]->biggest_col; i++)
{ /* This stuff happens for each cell... */
c = ws_array[sheet]->c_array[(row*ws_array[sheet]->max_cols)+i];
if (c)
{
int numeric = IsCellNumeric(c);
if (c->xfmt == 0)
{ /* Unknown format... */
left++;
}
else
{ /* Biff 8 stuff... */
if ((c->xfmt < next_xf)&&(c->ustr.str))
{
if (strcmp((char *)c->ustr.str, "&nbsp;"))
{
if (xf_array[c->xfmt])
{
switch(xf_array[c->xfmt]->align & 0x0007)
{ /* Override default table alignment when needed */
case 2:
case 6: /* Center across selection */
center++;
break;
case 0: /* General alignment */
if (numeric) /* Numbers */
right++;
else if ((c->type & 0x00FF) == 0x05) /* Boolean */
center++;
else
left++;
break;
case 3:
right++;
break;
case 1: /* fall through... */
default:
left++;
break;
}
}
}
}
}
}
}
if ((center == 0)&&(left == 0)&&(right == 0))
default_alignment = "";
else if ((center >= left)&&(center >= right)) /* Favor center since its the longest word */
default_alignment = "center";
else if ((right >= center)&&(right >= left))
default_alignment = "right"; /* Favor right since its second longest */
else
default_alignment = "left";
}
void OutputString(uni_string *u)
{
unsigned int i;
if (u == 0)
return;
if (u->uni < 2)
{
if (null_string(u->str))
{
if (Ascii == 0)
printf(OutputXML ? "" : "&nbsp;");
else if (!Csv)
printf(" ");
}
else
{
if (Ascii) /* If Ascii output requested, simply output the string */
{ /* These are broken up for performance */
if (Csv)
{
for (i=0; i<u->len; i++)
{
if (u->str[i] == 0x22)
printf("\"\"");
else
putchar(u->str[i]);
}
}
else
{
for (i=0; i<u->len; i++)
putchar(u->str[i]);
}
return;
}
if (u->crun_cnt)
{
U16 loc, fnt_idx, crun_cnt=0;
int format_changed = 0;
html_attr h_flags;
/* read the first format run */
update_crun_info(&loc, &fnt_idx, crun_cnt, u->fmt_run);
html_flag_init(&h_flags);
for (i=0; i<u->len; i++)
{
if (i == loc)
{ /* Time to change formats */
if (format_changed)
{ /* if old attributs, close */
output_end_html_attr(&h_flags);
if (h_flags.fflag)
printf("</FONT>");
}
else
{ /* FIXME: Also need to consider that a font may already be set for
the cell, in which case a closing tag should be set. */
format_changed = 1;
}
/* set new attr */
output_start_font_attribute(&h_flags, fnt_idx);
output_start_html_attr(&h_flags, fnt_idx, 1);
/* get next fmt_run */
if (crun_cnt < u->crun_cnt)
{
crun_cnt++;
update_crun_info(&loc, &fnt_idx, crun_cnt, u->fmt_run);
}
}
OutputCharCorrected(u->str[i]);
}
if (format_changed)
{
output_end_html_attr(&h_flags);
if (h_flags.fflag)
printf("</FONT>");
}
}
else
{
for (i=0; i<u->len; i++)
OutputCharCorrected(u->str[i]);
}
}
}
else
{
if (u->len == 0)
{
if (Ascii)
printf(" ");
else
printf(OutputXML ? "" : "&nbsp;");
}
else
{
if (u->len == 2)
{
if (memcmp(u->str, "& ", 2) == 0)
printf("&#8230;");
else
{
for (i=0; i<u->len; i+=2)
print_utf8(getShort(&(u->str[i])));
}
}
else
{
for (i=0; i<u->len; i+=2)
print_utf8(getShort(&(u->str[i])));
}
}
}
}
void OutputCharCorrected(U8 c)
{
if (MultiByte && (c & 0x80))
{
putchar(c);
return;
}
switch (c)
{ /* Special char handlers here... */
case 0x3C:
printf("&lt;");
break;
case 0x3E:
printf("&gt;");
break;
case 0x26:
printf("&amp;");
break;
case 0x22:
printf("&quot;");
break;
/* Also need to cover 128-159 since MS uses this area... */
case 0x80: /* Euro Symbol */
printf("&#8364;");
break;
case 0x82: /* baseline single quote */
printf("&#8218;");
break;
case 0x83: /* florin */
printf("&#402;");
break;
case 0x84: /* baseline double quote */
printf("&#8222;");
break;
case 0x85: /* ellipsis */
printf("&#8230;");
break;
case 0x86: /* dagger */
printf("&#8224;");
break;
case 0x87: /* double dagger */
printf("&#8225;");
break;
case 0x88: /* circumflex accent */
printf("&#710;");
break;
case 0x89: /* permile */
printf("&#8240;");
break;
case 0x8A: /* S Hacek */
printf("&#352;");
break;
case 0x8B: /* left single guillemet */
printf("&#8249;");
break;
case 0x8C: /* OE ligature */
printf("&#338;");
break;
case 0x8E: /* #LATIN CAPITAL LETTER Z WITH CARON */
printf("&#381;");
break;
case 0x91: /* left single quote ? */
printf("&#8216;");
break;
case 0x92: /* right single quote ? */
printf("&#8217;");
break;
case 0x93: /* left double quote */
printf("&#8220;");
break;
case 0x94: /* right double quote */
printf("&#8221;");
break;
case 0x95: /* bullet */
printf("&#8226;");
break;
case 0x96: /* endash */
printf("&#8211;");
break;
case 0x97: /* emdash */
printf("&#8212;");
break;
case 0x98: /* tilde accent */
printf("&#732;");
break;
case 0x99: /* trademark ligature */
printf("&#8482;");
break;
case 0x9A: /* s Haceks Hacek */
printf("&#353;");
break;
case 0x9B: /* right single guillemet */
printf("&#8250;");
break;
case 0x9C: /* oe ligature */
printf("&#339;");
break;
case 0x9F: /* Y Dieresis */
printf("&#376;");
break;
case 0xE1: /* a acute */
printf("<EFBFBD>");
break;
case 0xE9: /* e acute */
printf("<EFBFBD>");
break;
case 0xED: /* i acute */
printf("<EFBFBD>");
break;
case 0xF3: /* o acute */
printf("<EFBFBD>");
break;
case 0xFA: /* u acute */
printf("<EFBFBD>");
break;
case 0xFD: /* y acute */
printf("<EFBFBD>");
break;
case 0xB0: /* degrees */
printf("deg.");
break;
default:
putchar(c);
break;
}
}
void update_crun_info(U16 *loc, U16 *fmt_idx, U16 crun_cnt, U8 *fmt_run)
{
U16 tloc, tfmt_idx;
U16 offset = (U16)(crun_cnt*4);
tloc = getShort(&fmt_run[offset]);
tfmt_idx = getShort(&fmt_run[offset+2]);
*loc = tloc;
*fmt_idx = tfmt_idx;
}
void put_utf8(U16 c)
{
putchar((int)0x0080 | (c & 0x003F));
}
void print_utf8(U16 c)
{
if (c < 0x80)
OutputCharCorrected(c);
else if (c < 0x800)
{
putchar(0xC0 | (c >> 6));
put_utf8(c);
}
else
{
putchar(0xE0 | (c >> 12));
put_utf8((U16)(c >> 6));
put_utf8(c);
}
}
void uni_string_clear(uni_string *str)
{
if (str == 0)
return;
str->str = 0;
str->uni = 0;
str->len = 0;
str->fmt_run = 0;
str->crun_cnt = 0;
}
int uni_string_comp(uni_string *s1, uni_string *s2)
{
if ((s1 == 0)||(s2 == 0))
return -1;
if ((s1->str == 0)||(s2->str == 0))
return -1;
if ((s1->uni == s2->uni) && (s1->len == s2->len))
return memcmp(s1->str, s2->str, s1->len);
else
return -1;
}
void html_flag_init(html_attr *h)
{
h->fflag = 0;
h->bflag = 0;
h->iflag = 0;
h->sflag = 0;
h->uflag = 0;
h->sbflag = 0;
h->spflag = 0;
}
void output_start_font_attribute(html_attr *h, U16 fnt_idx)
{
if (uni_string_comp(&default_font, &(font_array[fnt_idx]->name)) != 0)
{
h->fflag = 1;
printf("<FONT FACE=\"");
OutputString(&(font_array[fnt_idx]->name));
printf("\"");
}
if (font_array[fnt_idx]->c_idx != 0x7FFF)
{
char color[8];
if (numCustomColors)
{
if ((font_array[fnt_idx]->c_idx < numCustomColors)&&use_colors)
strcpy(color, (char *)customColors[font_array[fnt_idx]->c_idx-8]);
else
strcpy(color, "000000");
}
else
{
if ((font_array[fnt_idx]->c_idx < MAX_COLORS)&&use_colors)
strcpy(color, colorTab[font_array[fnt_idx]->c_idx]);
else
strcpy(color, "000000");
}
if (strcmp(color, "000000") != 0)
{
if (h->fflag)
printf(" COLOR=\"%s\"", color);
else
{
h->fflag = 1;
printf("<FONT COLOR=\"%s\"", color);
}
}
}
if (font_array[fnt_idx]->super & 0x0003)
{
if (h->fflag)
printf(" SIZE=2"); /* Sub & Superscript */
else
{
h->fflag = 1;
printf("<FONT SIZE=2"); /* Sub & Superscript */
}
}
else
{
if (h->fflag)
{
if (font_array[fnt_idx]->size != default_fontsize)
printf(" SIZE=%d", font_array[fnt_idx]->size);
}
else
{
if (font_array[fnt_idx]->size != default_fontsize)
{
h->fflag = 1;
printf("<FONT SIZE=%d", font_array[fnt_idx]->size);
}
}
}
if (h->fflag)
printf(">");
}
Reference in New Issue View Git Blame Copy Permalink