glen
/
teapot-spreadsheet
1
1
Fork 0
Code Issues 48 Pull Requests Releases Wiki Activity
teapot-spreadsheet/src/common/wk1.c

1179 lines
31 KiB
C
Raw Normal View History

Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
/* #includes */ /*{{{C}}}*//*{{{*/
#ifndef NO_POSIX_SOURCE
#undef _POSIX_SOURCE
#define _POSIX_SOURCE 1
#undef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 2
#endif
#include <assert.h>
#include <errno.h>
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
Implement a relative reference robust to source and reference moving The new function is X(SRC,REF), which briefly for a cell in the neighborhood of REF returns the corresponding cell in the neighborhood in SRC. For further details, see the updated documention. In developing and documenting this function, I refined some of the existing error messages (e.g. showing the coordinates when there is an attempt to obtain a cell with a negative coordinate) and improved the error propagation to increase the chance that the innermost error will percolate to the top level.
2019-07-30 19:07:54 +00:00
extern char *strdup(const char *s);
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
#include <string.h>
#ifdef OLD_REALLOC
#define realloc(s,l) myrealloc(s,l)
#endif
#ifdef DMALLOC
#include "dmalloc.h"
#endif
#include "eval.h"
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
#include "parser.h"
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
#include "main.h"
#include "misc.h"
#include "sheet.h"
#include "wk1.h"
/*}}}*/
/* #defines */ /*{{{*/
#define WK1DEBUG 0
#define LOTUS123 0x0404
#define SYMPHONY 0x0405
/* Applix uses that, too */
#define EXCEL 0x0406
/*}}}*/
static int unrpn(const char *s, const int *offset, int top, Token **t, int *tokens);
#if WK1DEBUG
static FILE *se;
#endif
/* it -- convert string to int */ /*{{{*/
static int it(const char *s)
{
return (((unsigned int)((const unsigned char)*s))|(*(s+1)<<8));
}
/*}}}*/
/* dbl -- convert string to double */ /*{{{*/
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
static FltT dbl(const unsigned char *s)
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
{
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
FltT x;
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
int sg,e,i;
x=0.0;
for (i=1; i<256; i<<=1) x=x/2.0+!!(s[0]&i);
for (i=1; i<256; i<<=1) x=x/2.0+!!(s[1]&i);
for (i=1; i<256; i<<=1) x=x/2.0+!!(s[2]&i);
for (i=1; i<256; i<<=1) x=x/2.0+!!(s[3]&i);
for (i=1; i<256; i<<=1) x=x/2.0+!!(s[4]&i);
for (i=1; i<256; i<<=1) x=x/2.0+!!(s[5]&i);
x=x/2.0+!!(s[6]&0x01);
x=x/2.0+!!(s[6]&0x02);
x=x/2.0+!!(s[6]&0x04);
x=x/2.0+!!(s[6]&0x08);
x=x/2.0+1.0;
if ((e=((s[6]>>4)+((s[7]&0x7f)<<4))-1023)==-1023)
{
x=0.0;
e=0;
}
if (s[7]&0x80) sg=-1; else sg=1;
#if WK1DEBUG
fprintf(se,"%02x %02x %02x %02x %02x %02x %02x %02x ",s[0],s[1],s[2],s[3],s[4],s[5],s[6],s[7]);
fprintf(se,"%f (exp 2^%d)\r\n",sg*ldexp(x,e),e);
#endif
return (sg*ldexp(x,e));
}
/*}}}*/
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
/* format -- convert string into format */ /*{{{*/
static void format(unsigned char s, Cell *cell)
{
#if WK1DEBUG
fprintf(se,", format 0x%02x",s);
if (s&0x80) fprintf(se,", locked");
#endif
switch (((unsigned int)(s&0x70))>>4)
{
case 0: /* fixed with given precision */ /*{{{*/
{
Make tpa the default file format for Teapot There turned out to be one blocking technical issue for full adpotion of tpa format, and that was the fact that the printed representation of floating values inside the tpa file might not reproduce the same double when read. This change therefore introduces the "hexact" floating point format, based on the the %La format string, which produces a hex representation with exact round trips. While working on this, it was convenient to add a new representation "compact" which is basically the shorter of decimal and scientific representations, without trailing zeros. This is now the default float format, but of course one can select decimal or scientific formats to restore prior appearance. However, full-precision compact format is now the (only) format for editing cell contents, as it is accurate and efficient. Of course you can enter floating point values in any format you like when typing in a formula. The addition of several new floating point options overloaded the menus in terminal teapot, so this change also revamps those menus slightly, including eliminating the unused MenuChoice struct, and just specifying menus with an array of strings. Closes #63.
2019-08-24 16:58:46 +00:00
cell->precision = s&0x0f;
cell->fform = FLT_DECIMAL;
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
break;
}
/*}}}*/
case 1: /* scientifix with given presision */ /*{{{*/
{
Make tpa the default file format for Teapot There turned out to be one blocking technical issue for full adpotion of tpa format, and that was the fact that the printed representation of floating values inside the tpa file might not reproduce the same double when read. This change therefore introduces the "hexact" floating point format, based on the the %La format string, which produces a hex representation with exact round trips. While working on this, it was convenient to add a new representation "compact" which is basically the shorter of decimal and scientific representations, without trailing zeros. This is now the default float format, but of course one can select decimal or scientific formats to restore prior appearance. However, full-precision compact format is now the (only) format for editing cell contents, as it is accurate and efficient. Of course you can enter floating point values in any format you like when typing in a formula. The addition of several new floating point options overloaded the menus in terminal teapot, so this change also revamps those menus slightly, including eliminating the unused MenuChoice struct, and just specifying menus with an array of strings. Closes #63.
2019-08-24 16:58:46 +00:00
cell->precision = s&0x0f;
cell->fform = FLT_SCIENTIFIC;
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
break;
}
/*}}}*/
case 2: /* currency with given precision */ /*{{{*/
{
cell->precision=s&0x0f;
break;
}
/*}}}*/
case 3: /* percent with given precision */ /*{{{*/
{
cell->precision=s&0x0f;
break;
}
/*}}}*/
case 4: /* comma with given precision */ /*{{{*/
{
cell->precision=s&0x0f;
break;
}
/*}}}*/
case 5: /* unused */ break;
case 6: /* unused */ break;
case 7:
{
switch (s&0x0f)
{
case 0: /* +/- */; break;
case 1: /* general */; break;
case 2: /* day-month-year */; break;
case 3: /* day-month */; break;
case 4: /* month-year */; break;
case 5: /* text */; break;
case 6: /* hidden */; break;
case 7: /* date;hour-min-sec */; break;
case 8: /* date;hour-min */; break;
case 9: /* date;intnt'l1 */; break;
case 10: /* date;intnt'l2 */; break;
case 11: /* time;intnt'l1 */; break;
case 12: /* time;intnt'l2 */; break;
case 13: /* unused13 */; break;
case 14: /* unused14 */; break;
case 15: /* default special format */; break;
}
break;
}
}
}
/*}}}*/
/* pair -- convert coordinate pair */ /*{{{*/
static int pair(const char *s, Token **t, int *tokens)
{
int x,y;
x=it(s); y=it(s+2);
if (t)
{
if ((t[*tokens]=malloc(sizeof(Token)))==(Token*)0) return -1;
t[*tokens]->type=OPERATOR;
t[*tokens]->u.op=OP;
#if WK1DEBUG
fprintf(se,"[(");
#endif
}
if (tokens) ++(*tokens);
switch (x&0xc000)
{
case 0x0000: /* MSB -> 0 0 */ /*{{{*/
{
x=x&0x2000 ? x|0xc000 : x&0x3fff;
if (t)
{
if ((t[*tokens]=malloc(sizeof(Token)))==(Token*)0) return -1;
t[*tokens]->type=INT;
t[*tokens]->u.integer=x;
#if WK1DEBUG
fprintf(se,"%d",x);
#endif
}
if (tokens) ++(*tokens);
break;
}
/*}}}*/
case 0x4000: assert(0); break;
case 0x8000: /* MSB -> 1 0 */ /*{{{*/
{
x=x&0x2000 ? x|0xc000 : x&0x3fff;
if (x!=0)
{
if (t)
{
if ((t[*tokens]=malloc(sizeof(Token)))==(Token*)0 || (t[*tokens+1]=malloc(sizeof(Token)))==(Token*)0 || (t[*tokens+2]=malloc(sizeof(Token)))==(Token*)0) return -1;
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
t[*tokens]->type = FIDENT;
t[*tokens]->u.fident = FUNC_X;
t[*tokens+1]->type = OPERATOR;
t[*tokens+1]->u.op = OP;
t[*tokens+2]->type = OPERATOR;
t[*tokens+2]->u.op = CP;
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
#if WK1DEBUG
fprintf(se,"x()");
#endif
}
if (tokens) *tokens+=3;
if (t)
{
if ((t[*tokens]=malloc(sizeof(Token)))==(Token*)0 || (t[*tokens+1]=malloc(sizeof(Token)))==(Token*)0) return -1;
t[*tokens]->type=OPERATOR;
t[*tokens+1]->type=INT;
if (x<0)
{
t[*tokens]->u.op=MINUS;
t[*tokens+1]->u.integer=-x;
#if WK1DEBUG
fprintf(se,"-%d",-x);
#endif
}
else
{
t[*tokens]->u.op=PLUS;
t[*tokens+1]->u.integer=x;
#if WK1DEBUG
fprintf(se,"+%d",x);
#endif
}
}
if (tokens) *tokens+=2;
}
break;
}
/*}}}*/
case 0xc000: assert(0); break;
}
if (t)
{
if ((t[*tokens]=malloc(sizeof(Token)))==(Token*)0) return -1;
t[*tokens]->type=OPERATOR;
t[*tokens]->u.op=COMMA;
#if WK1DEBUG
fprintf(se,",");
#endif
}
if (tokens) ++(*tokens);
switch (y&0xc000)
{
case 0x0000: /* MSB -> 0 0 */ /*{{{*/
{
y=y&0x2000 ? y|0xc000 : y&0x3fff;
if (t)
{
if ((t[*tokens]=malloc(sizeof(Token)))==(Token*)0) return -1;
t[*tokens]->type=INT;
t[*tokens]->u.integer=y;
#if WK1DEBUG
fprintf(se,"%d",y);
#endif
}
if (tokens) ++(*tokens);
break;
}
/*}}}*/
case 0x4000: assert(0); break;
case 0x8000: /* MSB -> 1 0 */ /*{{{*/
{
y=y&0x2000 ? y|0xc000 : y&0x3fff;
if (y)
{
if (t)
{
if ((t[*tokens]=malloc(sizeof(Token)))==(Token*)0 || (t[*tokens+1]=malloc(sizeof(Token)))==(Token*)0 || (t[*tokens+2]=malloc(sizeof(Token)))==(Token*)0) return -1;
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
t[*tokens]->type = FIDENT;
t[*tokens]->u.fident = FUNC_Y;
t[*tokens+1]->type = OPERATOR;
t[*tokens+1]->u.op = OP;
t[*tokens+2]->type = OPERATOR;
t[*tokens+2]->u.op = CP;
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
#if WK1DEBUG
fprintf(se,"y()");
#endif
}
if (tokens) *tokens+=3;
if (t)
{
if ((t[*tokens]=malloc(sizeof(Token)))==(Token*)0 || (t[*tokens+1]=malloc(sizeof(Token)))==(Token*)0) return -1;
t[*tokens]->type=OPERATOR;
t[*tokens+1]->type=INT;
if (y<0)
{
if (t)
{
t[*tokens]->u.op=MINUS;
t[*tokens+1]->u.integer=-y;
#if WK1DEBUG
fprintf(se,"-%d",-y);
#endif
}
}
else
{
if (t)
{
t[*tokens]->u.op=PLUS;
t[*tokens+1]->u.integer=y;
#if WK1DEBUG
fprintf(se,"+%d",y);
#endif
}
}
}
if (tokens) *tokens+=2;
}
break;
}
/*}}}*/
case 0xc000: assert(0); break;
}
if (t)
{
if ((t[*tokens]=malloc(sizeof(Token)))==(Token*)0) return -1;
t[*tokens]->type=OPERATOR;
t[*tokens]->u.op=CP;
#if WK1DEBUG
fprintf(se,")]");
#endif
}
if (tokens) ++(*tokens);
return 0;
}
/*}}}*/
/* sumup -- sum up arguments */ /*{{{*/
static int sumup(const char *s, const int *offset, int top, Token **t, int *tokens, int argc)
{
int low;
if (top<0) return -1;
if (argc>1)
{
low=unrpn(s,offset,top,(Token**)0,(int*)0);
if (low<0) return -1;
sumup(s,offset,low-1,t,tokens,argc-1);
if (t)
{
if ((t[*tokens]=malloc(sizeof(Token)))==(Token*)0) return -1;
t[*tokens]->type=OPERATOR;
t[*tokens]->u.op=PLUS;
#if WK1DEBUG
fprintf(se,"[+]");
#endif
}
if (tokens) ++(*tokens);
}
if (s[offset[top]]==2)
{
if (t)
{
if ((t[*tokens]=malloc(sizeof(Token)))==(Token*)0 || (t[*tokens+1]=malloc(sizeof(Token)))==(Token*)0) return -1;
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
t[*tokens]->type = FIDENT;
t[*tokens]->u.fident = FUNC_SUM;
t[*tokens+1]->type = OPERATOR;
t[*tokens+1]->u.op = OP;
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
#if WK1DEBUG
fprintf(se,"[sum(]");
#endif
}
if (tokens) *tokens+=2;
}
low=unrpn(s,offset,top,t,tokens);
if (s[offset[top]]==2)
{
if (t)
{
if ((t[*tokens]=malloc(sizeof(Token)))==(Token*)0) return -1;
t[*tokens]->type=OPERATOR;
t[*tokens]->u.op=CP;
#if WK1DEBUG
fprintf(se,"[)]");
#endif
}
if (tokens) ++(*tokens);
}
return low;
}
/*}}}*/
/* unrpn -- convert RPN expression to infix */ /*{{{*/
static int unrpn(const char *s, const int *offset, int top, Token **t, int *tokens)
{
int low;
if (top<0) return -1;
switch (s[offset[top]])
{
case 0: /* double constant */ /*{{{*/
{
if (t)
{
if ((t[*tokens]=malloc(sizeof(Token)))==(Token*)0) return -1;
t[*tokens]->type=FLOAT;
t[*tokens]->u.flt=dbl((const unsigned char*)s+offset[top]+1);
#if WK1DEBUG
fprintf(se,"[constant %f]",dbl((const unsigned char*)s+offset[top]+1));
#endif
}
if (tokens) ++(*tokens);
low=top;
break;
}
/*}}}*/
case 1: /* variable */ /*{{{*/
{
if (t)
{
if ((t[*tokens]=malloc(sizeof(Token)))==(Token*)0) return -1;
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
t[*tokens]->type = FIDENT;
t[*tokens]->u.fident = FUNC_AT_SYMBOL;
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
}
if (tokens) ++(*tokens);
if (pair(s+offset[top]+1,t,tokens)==-1) low=-1; else low=top;
break;
}
/*}}}*/
case 2: /* range */ /*{{{*/
{
if (t)
{
if ((t[*tokens]=malloc(sizeof(Token)))==(Token*)0) return -1;
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
t[*tokens]->type = FIDENT;
t[*tokens]->u.fident = FUNC_AMPERSAND;
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
#if WK1DEBUG
fprintf(se,"[&]");
#endif
}
if (tokens) ++(*tokens);
pair(s+offset[top]+1,t,tokens);
if (t)
{
if ((t[*tokens]=malloc(sizeof(Token)))==(Token*)0 || (t[*tokens+1]=malloc(sizeof(Token)))==(Token*)0) return -1;
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
t[*tokens]->type = OPERATOR;
t[*tokens]->u.fident = COMMA;
t[*tokens+1]->type = FIDENT;
t[*tokens+1]->u.op = FUNC_AMPERSAND;
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
#if WK1DEBUG
fprintf(se,"[,&]");
#endif
}
if (tokens) *tokens+=2;
pair(s+offset[top]+5,t,tokens);
low=top;
break;
}
/*}}}*/
case 3: /* return */ /*{{{*/
{
low=unrpn(s,offset,top-1,t,tokens);
if (t)
{
t[*tokens]=(Token*)0;
#if WK1DEBUG
fprintf(se,"[RETURN]");
#endif
}
if (tokens) ++(*tokens);
break;
}
/*}}}*/
case 4: /* paren */ /*{{{*/
{
if (t)
{
if ((t[*tokens]=malloc(sizeof(Token)))==(Token*)0) return -1;
t[*tokens]->type=OPERATOR;
t[*tokens]->u.op=OP;
#if WK1DEBUG
fprintf(se,"[(]");
#endif
}
if (tokens) ++(*tokens);
low=unrpn(s,offset,top-1,t,tokens);
if (t)
{
if ((t[*tokens]=malloc(sizeof(Token)))==(Token*)0) return -1;
t[*tokens]->type=OPERATOR;
t[*tokens]->u.op=CP;
#if WK1DEBUG
fprintf(se,"[)]");
#endif
}
if (tokens) ++(*tokens);
break;
}
/*}}}*/
case 5: /* int constant */ /*{{{*/
{
if (t)
{
if ((t[*tokens]=malloc(sizeof(Token)))==(Token*)0) return -1;
t[*tokens]->type=INT;
t[*tokens]->u.integer=it(s+offset[top]+1);
#if WK1DEBUG
fprintf(se,"[constant %d]",it(s+offset[top]+1));
#endif
}
if (tokens) ++(*tokens);
low=top;
break;
}
/*}}}*/
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
case 16:
case 17:
case 18:
case 19: /* +, -, *, /, ^, -, !=, <=, >=, <, > */ /*{{{*/
{
if (t)
{
low=unrpn(s,offset,top-1,(Token**)0,(int*)0);
low=unrpn(s,offset,low-1,t,tokens);
if (low<0) return -1;
if ((t[*tokens]=malloc(sizeof(Token)))==(Token*)0) return -1;
t[*tokens]->type=OPERATOR;
switch (s[offset[top]])
{
case 9: /* + */ /*{{{*/
{
t[*tokens]->u.op=PLUS;
#if WK1DEBUG
fprintf(se,"[+]");
#endif
break;
}
/*}}}*/
case 10: /* - */ /*{{{*/
{
t[*tokens]->u.op=MINUS;
#if WK1DEBUG
fprintf(se,"[-]");
#endif
break;
}
/*}}}*/
case 11: /* * */ /*{{{*/
{
t[*tokens]->u.op=MUL;
#if WK1DEBUG
fprintf(se,"[*]");
#endif
break;
}
/*}}}*/
case 12: /* / */ /*{{{*/
{
t[*tokens]->u.op=DIV;
#if WK1DEBUG
fprintf(se,"[/]");
#endif
break;
}
/*}}}*/
case 13: /* ^ */ /*{{{*/
{
t[*tokens]->u.op=POW;
#if WK1DEBUG
fprintf(se,"[^]");
#endif
break;
}
/*}}}*/
case 14: /* == */ /*{{{*/
{
t[*tokens]->u.op=ISEQUAL;
#if WK1DEBUG
fprintf(se,"[==]");
#endif
break;
}
/*}}}*/
case 15: /* != */ /*{{{*/
{
t[*tokens]->u.op=NE;
#if WK1DEBUG
fprintf(se,"[!=]");
#endif
break;
}
/*}}}*/
case 16: /* <= */ /*{{{*/
{
t[*tokens]->u.op=LE;
#if WK1DEBUG
fprintf(se,"[<=]");
#endif
break;
}
/*}}}*/
case 17: /* >= */ /*{{{*/
{
t[*tokens]->u.op=GE;
#if WK1DEBUG
fprintf(se,"[>=]");
#endif
break;
}
/*}}}*/
case 18: /* < */ /*{{{*/
{
t[*tokens]->u.op=LT;
#if WK1DEBUG
fprintf(se,"[<]");
#endif
break;
}
/*}}}*/
case 19: /* > */ /*{{{*/
{
t[*tokens]->u.op=GT;
#if WK1DEBUG
fprintf(se,"[>]");
#endif
break;
}
/*}}}*/
default: assert(0);
}
if (tokens) ++(*tokens);
unrpn(s,offset,top-1,t,tokens);
}
else
{
low=unrpn(s,offset,top-1,(Token**)0,tokens);
if (tokens) ++(*tokens);
low=unrpn(s,offset,low-1,(Token**)0,tokens);
}
break;
}
/*}}}*/
case 23: /* unary + */ /*{{{*/
{
low=unrpn(s,offset,top-1,t,tokens);
break;
}
/*}}}*/
case 80: /* sum */ /*{{{*/
{
int argc;
argc=s[offset[top]+1];
#if WK1DEBUG
if (t) fprintf(se,"[sum argc=%d]",argc);
#endif
if (t)
{
if ((t[*tokens]=malloc(sizeof(Token)))==(Token*)0) return -1;
t[*tokens]->type=OPERATOR;
t[*tokens]->u.op=OP;
#if WK1DEBUG
fprintf(se,"[(]");
#endif
}
if (tokens) ++(*tokens);
low=sumup(s,offset,top-1,t,tokens,argc);
if (t)
{
if ((t[*tokens]=malloc(sizeof(Token)))==(Token*)0) return -1;
t[*tokens]->type=OPERATOR;
t[*tokens]->u.op=CP;
#if WK1DEBUG
fprintf(se,"[)]");
#endif
}
if (tokens) ++(*tokens);
break;
}
/*}}}*/
default: assert(0); low=-1;
}
return (low<0 ? -1 : low);
}
/*}}}*/
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
static char internal_errbuf[4096];
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
/* loadwk1 -- load WK1 file */ /*{{{*/
const char *loadwk1(Sheet *sheet, const char *name)
{
/* variables */ /*{{{*/
FILE *fp;
const char *err;
int head[4];
char *body=(char*)0,*newbody;
size_t bodymaxlen=0;
size_t bodylen;
A first stab at refactoring In general, the goal of these changes is to be more type-specific wherever possible, reduce duplicated code, and avoid magic numbers. The biggest individual change is to use Location triples of integers wherever possible rather than three separate int variables. Another very helpful change for understanding what is going on in the code is introducing the MarkState enum for tracking the process of marking and unmarking blocks of cell. The MarkState change was motivated by the issues with Ctrl-C, and this commit, in fact, resolves #28. Because of the lack of a test harness, it is possible that a change of this scope has created some bugs as well, but teapot was running OK for me at the time of the commit. However, I don't know how good my coverage of the changed code was -- I certainly did not save or load a Lotus 1-2-3 file!
2019-07-27 04:14:26 +00:00
Location tmp;
Cell *cell;
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
int found_bof=0,found_eof=0;
/*}}}*/
#if WK1DEBUG
se=fopen("/dev/tty","w"); assert(se!=(FILE*)0); fprintf(se,"\r\n");
#endif
if ((fp=fopen(name,"r"))==(FILE*)0) return strerror(errno);
err=(const char*)0;
while (1)
{
/* read header */ /*{{{*/
if ((head[0]=getc(fp))==EOF) break;
if ((head[1]=getc(fp))==EOF) { err=_("The record header appears to be truncated"); goto ouch; }
if ((head[2]=getc(fp))==EOF) { err=_("The record header appears to be truncated"); goto ouch; }
if ((head[3]=getc(fp))==EOF) { err=_("The record header appears to be truncated"); goto ouch; }
bodylen=head[2]|(head[3]<<8);
/*}}}*/
/* read body */ /*{{{*/
if (bodylen>bodymaxlen)
{
newbody=realloc(body,bodymaxlen=bodylen);
if (newbody==(char*)0) { err=_("Out of memory"); goto ouch; }
else body=newbody;
}
if (bodylen) if (fread(body,bodylen,1,fp)!=1) { err=_("The record body appears to be truncated"); goto ouch; }
/*}}}*/
/* process record */ /*{{{*/
#if WK1DEBUG
fprintf(se,"bodylen %d, type %04x\r\n",bodylen,head[0]|(head[1]<<8));
#endif
switch (head[0]|(head[1]<<8))
{
/* BOF -- Beginning of file */ /*{{{*/
case 0x0:
{
if (bodylen!=2) { err=_("Invalid record body length"); goto ouch; }
if (!found_bof)
{
freesheet(sheet,0);
found_bof=it(body);
}
break;
}
/*}}}*/
/* EOF -- End of file */ /*{{{*/
case 0x1:
{
if (bodylen!=0) { err=_("Invalid record body length"); goto ouch; }
found_eof=1;
break;
}
/*}}}*/
/* CALCMODE -- Calculation mode */ /*{{{*/
case 0x2:
{
if (bodylen!=1) { err=_("Invalid record body length"); goto ouch; }
/* (unsigned char)body[0] means: */
/* 0 -- manual */
/* 0xff -- automatic */
break;
}
/*}}}*/
/* CALCORDER -- Calculation order */ /*{{{*/
case 0x3:
{
if (bodylen!=1) { err=_("Invalid record body length"); goto ouch; }
/* (unsigned char)body[0] means: */
/* 0 -- natural */
/* 1 -- by column */
/* 0xff -- by row */
break;
}
/*}}}*/
/* SPLIT -- Split window type */ /*{{{*/
case 0x4:
{
if (bodylen!=1) { err=_("Invalid record body length"); goto ouch; }
/* (unsigned)body[0] means: */
/* 0: not split */
/* 1: vertical split */
/* 0xff: horizontal split */
break;
}
/*}}}*/
/* SYNC -- Split window sync */ /*{{{*/
case 0x5:
{
if (bodylen!=1) { err=_("Invalid record body length"); goto ouch; }
/* (unsigned)body[0] means: */
/* 0: not synchronized */
/* 0xff: synchronized */
break;
}
/*}}}*/
/* RANGE -- Active worksheet range */ /*{{{*/
case 0x6:
{
if (bodylen!=8) { err=_("Invalid record body length"); goto ouch; }
Make tpa the default file format for Teapot There turned out to be one blocking technical issue for full adpotion of tpa format, and that was the fact that the printed representation of floating values inside the tpa file might not reproduce the same double when read. This change therefore introduces the "hexact" floating point format, based on the the %La format string, which produces a hex representation with exact round trips. While working on this, it was convenient to add a new representation "compact" which is basically the shorter of decimal and scientific representations, without trailing zeros. This is now the default float format, but of course one can select decimal or scientific formats to restore prior appearance. However, full-precision compact format is now the (only) format for editing cell contents, as it is accurate and efficient. Of course you can enter floating point values in any format you like when typing in a formula. The addition of several new floating point options overloaded the menus in terminal teapot, so this change also revamps those menus slightly, including eliminating the unused MenuChoice struct, and just specifying menus with an array of strings. Closes #63.
2019-08-24 16:58:46 +00:00
resize(sheet, it(body+4), it(body+6), 0, NULL);
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
/* range is from &(it(body),it(body+2)) to &(it(body+4),it(body+6)) */
break;
}
/*}}}*/
/* WINDOW1 -- Window 1 record */ /*{{{*/
case 0x7:
{
/* 31 is the specification, but Applix generates 32 while claiming to be Excel */
if (bodylen!=31 && (found_bof!=EXCEL && bodylen!=32)) { err=_("Invalid record body length"); goto ouch; }
break;
}
/*}}}*/
/* COLW1 -- Column width, window 1 */ /*{{{*/
case 0x8:
{
if (bodylen!=3) { err=_("Invalid record body length"); goto ouch; }
break;
}
/*}}}*/
/* WINTWO -- Window 2 record */ /*{{{*/
case 0x9:
{
if (bodylen!=31) { err=_("Invalid record body length"); goto ouch; }
break;
}
/*}}}*/
/* COLW2 -- Column width, window 2 */ /*{{{*/
case 0xA:
{
if (bodylen!=3) { err=_("Invalid record body length"); goto ouch; }
break;
}
/*}}}*/
/* _("nN)ame") -- Named range */ /*{{{*/
case 0xB:
{
if (bodylen!=24) { err=_("Invalid record body length"); goto ouch; }
break;
}
/*}}}*/
/* BLANK -- Blank cell */ /*{{{*/
case 0xC:
{
if (bodylen!=5) { err=_("Invalid record body length"); goto ouch; }
A first stab at refactoring In general, the goal of these changes is to be more type-specific wherever possible, reduce duplicated code, and avoid magic numbers. The biggest individual change is to use Location triples of integers wherever possible rather than three separate int variables. Another very helpful change for understanding what is going on in the code is introducing the MarkState enum for tracking the process of marking and unmarking blocks of cell. The MarkState change was motivated by the issues with Ctrl-C, and this commit, in fact, resolves #28. Because of the lack of a test harness, it is possible that a change of this scope has created some bugs as well, but teapot was running OK for me at the time of the commit. However, I don't know how good my coverage of the changed code was -- I certainly did not save or load a Lotus 1-2-3 file!
2019-07-27 04:14:26 +00:00
tmp[X] = it(body+1); tmp[Y] = it(body+3); tmp[Z] = 0;
Make tpa the default file format for Teapot There turned out to be one blocking technical issue for full adpotion of tpa format, and that was the fact that the printed representation of floating values inside the tpa file might not reproduce the same double when read. This change therefore introduces the "hexact" floating point format, based on the the %La format string, which produces a hex representation with exact round trips. While working on this, it was convenient to add a new representation "compact" which is basically the shorter of decimal and scientific representations, without trailing zeros. This is now the default float format, but of course one can select decimal or scientific formats to restore prior appearance. However, full-precision compact format is now the (only) format for editing cell contents, as it is accurate and efficient. Of course you can enter floating point values in any format you like when typing in a formula. The addition of several new floating point options overloaded the menus in terminal teapot, so this change also revamps those menus slightly, including eliminating the unused MenuChoice struct, and just specifying menus with an array of strings. Closes #63.
2019-08-24 16:58:46 +00:00
cell = initcellofsheet(sheet, tmp, NULL);
A first stab at refactoring In general, the goal of these changes is to be more type-specific wherever possible, reduce duplicated code, and avoid magic numbers. The biggest individual change is to use Location triples of integers wherever possible rather than three separate int variables. Another very helpful change for understanding what is going on in the code is introducing the MarkState enum for tracking the process of marking and unmarking blocks of cell. The MarkState change was motivated by the issues with Ctrl-C, and this commit, in fact, resolves #28. Because of the lack of a test harness, it is possible that a change of this scope has created some bugs as well, but teapot was running OK for me at the time of the commit. However, I don't know how good my coverage of the changed code was -- I certainly did not save or load a Lotus 1-2-3 file!
2019-07-27 04:14:26 +00:00
format((unsigned char)body[0], cell);
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
break;
}
/*}}}*/
/* INTEGER -- Integer number cell */ /*{{{*/
case 0xD:
{
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
Token t;
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
assert(bodylen == 7);
A first stab at refactoring In general, the goal of these changes is to be more type-specific wherever possible, reduce duplicated code, and avoid magic numbers. The biggest individual change is to use Location triples of integers wherever possible rather than three separate int variables. Another very helpful change for understanding what is going on in the code is introducing the MarkState enum for tracking the process of marking and unmarking blocks of cell. The MarkState change was motivated by the issues with Ctrl-C, and this commit, in fact, resolves #28. Because of the lack of a test harness, it is possible that a change of this scope has created some bugs as well, but teapot was running OK for me at the time of the commit. However, I don't know how good my coverage of the changed code was -- I certainly did not save or load a Lotus 1-2-3 file!
2019-07-27 04:14:26 +00:00
tmp[X] = it(body+1); tmp[Y] = it(body+3); tmp[Z] = 0;
Make tpa the default file format for Teapot There turned out to be one blocking technical issue for full adpotion of tpa format, and that was the fact that the printed representation of floating values inside the tpa file might not reproduce the same double when read. This change therefore introduces the "hexact" floating point format, based on the the %La format string, which produces a hex representation with exact round trips. While working on this, it was convenient to add a new representation "compact" which is basically the shorter of decimal and scientific representations, without trailing zeros. This is now the default float format, but of course one can select decimal or scientific formats to restore prior appearance. However, full-precision compact format is now the (only) format for editing cell contents, as it is accurate and efficient. Of course you can enter floating point values in any format you like when typing in a formula. The addition of several new floating point options overloaded the menus in terminal teapot, so this change also revamps those menus slightly, including eliminating the unused MenuChoice struct, and just specifying menus with an array of strings. Closes #63.
2019-08-24 16:58:46 +00:00
cell = initcellofsheet(sheet, tmp, NULL);
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
t.type = INT;
t.u.integer = it(body+5);
puttok(sheet, tmp, t, BASE_CONT);
A first stab at refactoring In general, the goal of these changes is to be more type-specific wherever possible, reduce duplicated code, and avoid magic numbers. The biggest individual change is to use Location triples of integers wherever possible rather than three separate int variables. Another very helpful change for understanding what is going on in the code is introducing the MarkState enum for tracking the process of marking and unmarking blocks of cell. The MarkState change was motivated by the issues with Ctrl-C, and this commit, in fact, resolves #28. Because of the lack of a test harness, it is possible that a change of this scope has created some bugs as well, but teapot was running OK for me at the time of the commit. However, I don't know how good my coverage of the changed code was -- I certainly did not save or load a Lotus 1-2-3 file!
2019-07-27 04:14:26 +00:00
format((unsigned char)body[0], cell);
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
break;
}
/*}}}*/
/* NUMBER -- Floating point number */ /*{{{*/
case 0xE:
{
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
Token t;
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
assert(bodylen == 13);
A first stab at refactoring In general, the goal of these changes is to be more type-specific wherever possible, reduce duplicated code, and avoid magic numbers. The biggest individual change is to use Location triples of integers wherever possible rather than three separate int variables. Another very helpful change for understanding what is going on in the code is introducing the MarkState enum for tracking the process of marking and unmarking blocks of cell. The MarkState change was motivated by the issues with Ctrl-C, and this commit, in fact, resolves #28. Because of the lack of a test harness, it is possible that a change of this scope has created some bugs as well, but teapot was running OK for me at the time of the commit. However, I don't know how good my coverage of the changed code was -- I certainly did not save or load a Lotus 1-2-3 file!
2019-07-27 04:14:26 +00:00
tmp[X] = it(body+1); tmp[Y] = it(body+3); tmp[Z] = 0;
Make tpa the default file format for Teapot There turned out to be one blocking technical issue for full adpotion of tpa format, and that was the fact that the printed representation of floating values inside the tpa file might not reproduce the same double when read. This change therefore introduces the "hexact" floating point format, based on the the %La format string, which produces a hex representation with exact round trips. While working on this, it was convenient to add a new representation "compact" which is basically the shorter of decimal and scientific representations, without trailing zeros. This is now the default float format, but of course one can select decimal or scientific formats to restore prior appearance. However, full-precision compact format is now the (only) format for editing cell contents, as it is accurate and efficient. Of course you can enter floating point values in any format you like when typing in a formula. The addition of several new floating point options overloaded the menus in terminal teapot, so this change also revamps those menus slightly, including eliminating the unused MenuChoice struct, and just specifying menus with an array of strings. Closes #63.
2019-08-24 16:58:46 +00:00
cell = initcellofsheet(sheet, tmp, NULL);
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
t.type = FLOAT;
t.u.flt = dbl((unsigned char*)body+5);
puttok(sheet, tmp, t, BASE_CONT);
A first stab at refactoring In general, the goal of these changes is to be more type-specific wherever possible, reduce duplicated code, and avoid magic numbers. The biggest individual change is to use Location triples of integers wherever possible rather than three separate int variables. Another very helpful change for understanding what is going on in the code is introducing the MarkState enum for tracking the process of marking and unmarking blocks of cell. The MarkState change was motivated by the issues with Ctrl-C, and this commit, in fact, resolves #28. Because of the lack of a test harness, it is possible that a change of this scope has created some bugs as well, but teapot was running OK for me at the time of the commit. However, I don't know how good my coverage of the changed code was -- I certainly did not save or load a Lotus 1-2-3 file!
2019-07-27 04:14:26 +00:00
format((unsigned char)body[0], cell);
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
break;
}
/*}}}*/
/* _("lL)abel") -- Label cell */ /*{{{*/
case 0xF:
{
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
Token t;
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
assert(bodylen >= 6 && bodylen <= 245);
A first stab at refactoring In general, the goal of these changes is to be more type-specific wherever possible, reduce duplicated code, and avoid magic numbers. The biggest individual change is to use Location triples of integers wherever possible rather than three separate int variables. Another very helpful change for understanding what is going on in the code is introducing the MarkState enum for tracking the process of marking and unmarking blocks of cell. The MarkState change was motivated by the issues with Ctrl-C, and this commit, in fact, resolves #28. Because of the lack of a test harness, it is possible that a change of this scope has created some bugs as well, but teapot was running OK for me at the time of the commit. However, I don't know how good my coverage of the changed code was -- I certainly did not save or load a Lotus 1-2-3 file!
2019-07-27 04:14:26 +00:00
tmp[X] = it(body+1); tmp[Y] = it(body+3); tmp[Z] = 0;
Make tpa the default file format for Teapot There turned out to be one blocking technical issue for full adpotion of tpa format, and that was the fact that the printed representation of floating values inside the tpa file might not reproduce the same double when read. This change therefore introduces the "hexact" floating point format, based on the the %La format string, which produces a hex representation with exact round trips. While working on this, it was convenient to add a new representation "compact" which is basically the shorter of decimal and scientific representations, without trailing zeros. This is now the default float format, but of course one can select decimal or scientific formats to restore prior appearance. However, full-precision compact format is now the (only) format for editing cell contents, as it is accurate and efficient. Of course you can enter floating point values in any format you like when typing in a formula. The addition of several new floating point options overloaded the menus in terminal teapot, so this change also revamps those menus slightly, including eliminating the unused MenuChoice struct, and just specifying menus with an array of strings. Closes #63.
2019-08-24 16:58:46 +00:00
cell = initcellofsheet(sheet, tmp, NULL);
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
t.type = STRING;
t.u.string = strdup(body+6);
puttok(sheet, tmp, t, BASE_CONT);
A first stab at refactoring In general, the goal of these changes is to be more type-specific wherever possible, reduce duplicated code, and avoid magic numbers. The biggest individual change is to use Location triples of integers wherever possible rather than three separate int variables. Another very helpful change for understanding what is going on in the code is introducing the MarkState enum for tracking the process of marking and unmarking blocks of cell. The MarkState change was motivated by the issues with Ctrl-C, and this commit, in fact, resolves #28. Because of the lack of a test harness, it is possible that a change of this scope has created some bugs as well, but teapot was running OK for me at the time of the commit. However, I don't know how good my coverage of the changed code was -- I certainly did not save or load a Lotus 1-2-3 file!
2019-07-27 04:14:26 +00:00
format((unsigned char)body[0], cell);
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
break;
}
/*}}}*/
/* FORMULA -- Formula cell */ /*{{{*/
case 0x10:
{
int i,j,size;
int *offset;
int tokens;
Token **t;
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
assert(bodylen > 15);
if ((offset = malloc(it(body+13)*sizeof(int))) == 0)
{
err = _("Out of memory");
goto ouch;
}
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
#if WK1DEBUG
fprintf(se,"FORMULA: &(%d,%d)=",it(body+1),it(body+3));
#endif
for (i=15,size=it(body+13)+15,j=0; i<size; ++i,++j)
{
offset[j]=i;
switch(body[i])
{
case 0: /* double constant */ /*{{{*/
{
i+=8;
break;
}
/*}}}*/
case 1: /* variable */ /*{{{*/
{
i+=4;
break;
}
/*}}}*/
case 2: /* range */ /*{{{*/
{
i+=8;
break;
}
/*}}}*/
case 5: /* int constant */ /*{{{*/
{
i+=2;
break;
}
/*}}}*/
case 80: /* sum */ /*{{{*/
{
++i;
break;
}
/*}}}*/
}
}
#if WK1DEBUG
fprintf(se,", value %f",dbl((unsigned char*)body+5));
#endif
A first stab at refactoring In general, the goal of these changes is to be more type-specific wherever possible, reduce duplicated code, and avoid magic numbers. The biggest individual change is to use Location triples of integers wherever possible rather than three separate int variables. Another very helpful change for understanding what is going on in the code is introducing the MarkState enum for tracking the process of marking and unmarking blocks of cell. The MarkState change was motivated by the issues with Ctrl-C, and this commit, in fact, resolves #28. Because of the lack of a test harness, it is possible that a change of this scope has created some bugs as well, but teapot was running OK for me at the time of the commit. However, I don't know how good my coverage of the changed code was -- I certainly did not save or load a Lotus 1-2-3 file!
2019-07-27 04:14:26 +00:00
format((unsigned char)body[0],CELL_ATC(sheet,it(body+1),it(body+3),0));
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
#if WK1DEBUG
fprintf(se,"\r\n");
#endif
tokens=0; unrpn(body,offset,j-1,(Token**)0,&tokens);
if ((t=malloc(tokens*sizeof(Token*)))==(Token**)0)
{
free(offset);
err=_("Out of memory");
goto ouch;
}
for (; tokens; --tokens) t[tokens-1]=(Token*)0;
if (unrpn(body,offset,j-1,t,&tokens)==-1)
{
err=_("Out of memory");
tvecfree(t);
goto ouch;
}
else
{
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
Token tok = eval_safe(t, LITERAL);
tvecfree(t);
if (tok.type == EEK)
{
strcpy(internal_errbuf, _("Parse error: "));
strcat(internal_errbuf, tok.u.err);
tfree(&tok);
err = internal_errbuf;
goto ouch;
}
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
#if WK1DEBUG
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
fprintf(se,"[<-- %d tokens]\r\n",tokens);
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
#endif
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
free(offset);
tmp[X] = it(body+1); tmp[Y] = it(body+3); tmp[Z] = 0;
Make tpa the default file format for Teapot There turned out to be one blocking technical issue for full adpotion of tpa format, and that was the fact that the printed representation of floating values inside the tpa file might not reproduce the same double when read. This change therefore introduces the "hexact" floating point format, based on the the %La format string, which produces a hex representation with exact round trips. While working on this, it was convenient to add a new representation "compact" which is basically the shorter of decimal and scientific representations, without trailing zeros. This is now the default float format, but of course one can select decimal or scientific formats to restore prior appearance. However, full-precision compact format is now the (only) format for editing cell contents, as it is accurate and efficient. Of course you can enter floating point values in any format you like when typing in a formula. The addition of several new floating point options overloaded the menus in terminal teapot, so this change also revamps those menus slightly, including eliminating the unused MenuChoice struct, and just specifying menus with an array of strings. Closes #63.
2019-08-24 16:58:46 +00:00
cell = initcellofsheet(sheet, tmp, NULL);
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
cell->tok[CURR_VAL].type = FLOAT;
cell->tok[CURR_VAL].u.flt = dbl((unsigned char*)body+5);
puttok(sheet, tmp, tok, BASE_CONT);
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
}
break;
}
/*}}}*/
/* TABLE -- Data table range */ /*{{{*/
case 0x18: assert(bodylen==25); break;
/*}}}*/
/* ORANGE/QRANGE -- Query range */ /*{{{*/
case 0x19: assert(bodylen==25); break;
/*}}}*/
/* PRANGE -- Print range */ /*{{{*/
case 0x1A: assert(bodylen==8); break;
/*}}}*/
/* SRANGE -- Sort range */ /*{{{*/
case 0x1B: assert(bodylen==8); break;
/*}}}*/
/* FRANGE -- Fill range */ /*{{{*/
case 0x1C: assert(bodylen==8); break;
/*}}}*/
/* KRANGE1 -- Primary sort key range */ /*{{{*/
case 0x1D: assert(bodylen==9); break;
/*}}}*/
/* HRANGE -- Distribution range */ /*{{{*/
case 0x20: assert(bodylen==16); break;
/*}}}*/
/* KRANGE2 -- Secondary sort key range */ /*{{{*/
case 0x23: assert(bodylen==9); break;
/*}}}*/
/* PROTEC -- Global protection */ /*{{{*/
case 0x24:
{
if (bodylen!=1) { err=_("Invalid record body length"); goto ouch; }
/* (unsigned)body[0] means: */
/* 0: off */
/* 0xff: on */
break;
}
/*}}}*/
/* FOOTER -- Print footer */ /*{{{*/
case 0x25:
{
if (body[bodylen-1]!='\0' || bodylen<1 || bodylen>243) { err=_("Invalid record body length"); goto ouch; }
break;
}
/*}}}*/
/* HEADER -- Print header */ /*{{{*/
case 0x26:
{
if (body[bodylen-1]!='\0' || bodylen<1 || bodylen>243) { err=_("Invalid record body length"); goto ouch; }
break;
}
/*}}}*/
/* SETUP -- Print setup */ /*{{{*/
case 0x27: assert(bodylen==40); break;
/*}}}*/
/* MARGINS -- Print margins code */ /*{{{*/
case 0x28: assert(bodylen==10); break;
/*}}}*/
/* LABELFMT -- Label alignment */ /*{{{*/
case 0x29:
{
if (bodylen!=1) { err=_("Invalid record body length"); goto ouch; }
/* (unsigned char)body[0] means: */
/* 0x22: right aligned labels */
/* 0x27: left aligned labels */
/* 0x5e: centered labels */
break;
}
/*}}}*/
/* TITLES -- Print borders */ /*{{{*/
case 0x2A: assert(bodylen==16); break;
/*}}}*/
/* GRAPH -- Current graph settings */ /*{{{*/
case 0x2D:
{
/* The specification says bodylen is 437, Excel 5 says it are */
/* 443 bytes. We better silently ignore this. */
break;
}
/*}}}*/
/* NGRAPH -- Named graph settings */ /*{{{*/
case 0x2E: assert(bodylen==453); break;
/*}}}*/
/* CALCCOUNT -- Iteration count */ /*{{{*/
case 0x2F:
{
if (bodylen!=1) { err=_("Invalid record body length"); goto ouch; }
/* Do up to %d Iterations */
break;
}
/*}}}*/
/* UNFORMATTED -- Formatted/unformatted print */ /*{{{*/
case 0x30: assert(bodylen==1); break;
/*}}}*/
/* CURSORW12 -- Cursor location */ /*{{{*/
case 0x31:
{
if (bodylen!=1) { err=_("Invalid record body length"); goto ouch; }
/* (unsigned)body[0] means cursor in window: */
/* 1: 1 */
/* 2: 2 */
break;
}
/*}}}*/
/* WINDOW -- Symphony window settings */ /*{{{*/
case 0x32: assert(bodylen==144); break;
/*}}}*/
/* STRING -- Value of string formula */ /*{{{*/
case 0x33:
{
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
Token t;
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
assert(bodylen>=6 && bodylen<=245);
A first stab at refactoring In general, the goal of these changes is to be more type-specific wherever possible, reduce duplicated code, and avoid magic numbers. The biggest individual change is to use Location triples of integers wherever possible rather than three separate int variables. Another very helpful change for understanding what is going on in the code is introducing the MarkState enum for tracking the process of marking and unmarking blocks of cell. The MarkState change was motivated by the issues with Ctrl-C, and this commit, in fact, resolves #28. Because of the lack of a test harness, it is possible that a change of this scope has created some bugs as well, but teapot was running OK for me at the time of the commit. However, I don't know how good my coverage of the changed code was -- I certainly did not save or load a Lotus 1-2-3 file!
2019-07-27 04:14:26 +00:00
tmp[X] = it(body+1); tmp[Y] = it(body+3); tmp[Z] = 0;
Make tpa the default file format for Teapot There turned out to be one blocking technical issue for full adpotion of tpa format, and that was the fact that the printed representation of floating values inside the tpa file might not reproduce the same double when read. This change therefore introduces the "hexact" floating point format, based on the the %La format string, which produces a hex representation with exact round trips. While working on this, it was convenient to add a new representation "compact" which is basically the shorter of decimal and scientific representations, without trailing zeros. This is now the default float format, but of course one can select decimal or scientific formats to restore prior appearance. However, full-precision compact format is now the (only) format for editing cell contents, as it is accurate and efficient. Of course you can enter floating point values in any format you like when typing in a formula. The addition of several new floating point options overloaded the menus in terminal teapot, so this change also revamps those menus slightly, including eliminating the unused MenuChoice struct, and just specifying menus with an array of strings. Closes #63.
2019-08-24 16:58:46 +00:00
cell = initcellofsheet(sheet, tmp, NULL);
Streamline internals of teapot The primary change is to add a “funcall” token, so that an entire expression can be encapsulated as a single token. This change is used to allow a cell to include simply a selection of appropriate semantic tokens. I.e., the content and iterative content are now each a single token like the value and the result value. Token vectors are used only as intermediate results in scanning and parsing. Not this means the cells are now in effect storing parse trees, so computation should be slightly faster and future extensions (like #56) should be facilitated. This commit also takes the opportunity while internals are being altered to add another token to a cell for future use for computed attributes, cf #22, and to change the internal numerical values from double and ints to long doubles and long longs. However, the change attempts to encapsulate that choice so it would be easy to change back or change to another representation. Note that these changes break savexdr(), as the internal binary format of a cell is now different. Rather than reimplement it, it is deprecated as the world does not need another binary spreadsheet format. Hence, the ascii format for teapot spreadsheets becomes the primary file format. Loading of old xdr files is still supported for backward compatibility. Closes #59. Also along the way, various other slight fixes and enhancements crept in, a partial but probably not exhaustive list of which follows: Fixes #31. Further revisions and improvements to documentation. Make the approximate comparison of floating point values scale more accurately with the size of the doubles being compared. Further extensions of absolute and relative cell addressing. Addition of (circle constant) tau function/constant. Modified string conversion to simply use internal printing routines, and to take "scientific" and "decimal" keywords. Allowed n() function to take a list of values, or just a single location defaulting to the current location. Added floor, ceil, trunc, and round functions, and allowed them to be keywords controlling the int() integer conversion function as well. Allowed substr() to drop its last argument to go to the end of the string. Provided an enum of built-in functions to preserve legacy function identifiers, allowing the large table inside func.c to be reorganized in a clearer fashion. Added additional annotation of properties of the built-in functions, including precedence. All operators are now also accessible as built-in functions. Made precedence of unary - lower than ^ to match python. Avoided inadvertently using FLTK @symbol abbreviations for formulas with "@" in them.
2019-08-23 19:12:06 +00:00
t.type = STRING;
t.u.string = strdup(body+5);
puttok(sheet, tmp, t, BASE_CONT);
A first stab at refactoring In general, the goal of these changes is to be more type-specific wherever possible, reduce duplicated code, and avoid magic numbers. The biggest individual change is to use Location triples of integers wherever possible rather than three separate int variables. Another very helpful change for understanding what is going on in the code is introducing the MarkState enum for tracking the process of marking and unmarking blocks of cell. The MarkState change was motivated by the issues with Ctrl-C, and this commit, in fact, resolves #28. Because of the lack of a test harness, it is possible that a change of this scope has created some bugs as well, but teapot was running OK for me at the time of the commit. However, I don't know how good my coverage of the changed code was -- I certainly did not save or load a Lotus 1-2-3 file!
2019-07-27 04:14:26 +00:00
format((unsigned char)body[0], cell);
Import exactly the files of the teapot-2.3.0 distribution
2019-07-22 20:32:33 +00:00
break;
}
/*}}}*/
/* PASSWORD -- File lockout (CHKSUM) */ /*{{{*/
case 0x37: assert(bodylen==4); break;
/*}}}*/
/* LOCKED -- Lock flag */ /*{{{*/
case 0x38: assert(bodylen==1); break;
/*}}}*/
/* QUERY -- Symphony query settings */ /*{{{*/
case 0x3C: assert(bodylen==127); break;
/*}}}*/
/* QUERYNAME -- Query name */ /*{{{*/
case 0x3D: assert(bodylen==16); break;
/*}}}*/
/* PRINT -- Symphony print record */ /*{{{*/
case 0x3E: assert(bodylen==679); break;
/*}}}*/
/* PRINTNAME -- Print record name */ /*{{{*/
case 0x3F: assert(bodylen==16); break;
/*}}}*/
/* GRAPH2 -- Symphony graph record */ /*{{{*/
case 0x40: assert(bodylen==499); break;
/*}}}*/
/* GRAPHNAME -- Graph record name */ /*{{{*/
case 0x41: assert(bodylen==16); break;
/*}}}*/
/* ZOOM -- Orig coordinates expanded window */ /*{{{*/
case 0x42: assert(bodylen==9); break;
/*}}}*/
/* SYMSPLIT -- No. of split windows */ /*{{{*/
case 0x43: assert(bodylen==2); break;
/*}}}*/
/* NSROWS -- No. of screen rows */ /*{{{*/
case 0x44: assert(bodylen==2); break;
/*}}}*/
/* NSCOLS -- No. of screen columns */ /*{{{*/
case 0x45: assert(bodylen==2); break;
/*}}}*/
/* RULER -- Named ruler range */ /*{{{*/
case 0x46: assert(bodylen==25); break;
/*}}}*/
/* NNAME -- Named sheet range */ /*{{{*/
case 0x47: assert(bodylen==25); break;
/*}}}*/
/* ACOMM -- Autoload.comm code */ /*{{{*/
case 0x48: assert(bodylen==65); break;
/*}}}*/
/* AMACRO -- Autoexecute macro address */ /*{{{*/
case 0x49: assert(bodylen==8); break;
/*}}}*/
/* PARSE -- Query parse information */ /*{{{*/
case 0x4A: assert(bodylen==16); break;
/*}}}*/
}
/*}}}*/
if (!found_bof) { err=_("This is not a WK1 file"); goto ouch; }
}
if (!found_eof) err=_("File truncated");
ouch:
if (body) free(body);
if (fclose(fp)==EOF && err==(const char*)0) err=strerror(errno);
sheet->changed=0;
cachelabels(sheet);
forceupdate(sheet);
return err;
}
/*}}}*/